mirror of https://github.com/PentHertz/srsLTE.git
Changed until precoding.h
This commit is contained in:
parent
7eecf5be3b
commit
0d71c911fe
|
@ -26,7 +26,7 @@ for i=1:length(trBlkLenVec)
|
|||
mat2 = reshape(reshape(mat{1},[],3)',[],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);
|
||||
|
||||
if (length(trBlkLenVec) == 1)
|
||||
|
|
|
@ -71,7 +71,7 @@ int generate_input_signal(void *in, int *lengths)
|
|||
lengths[0] = block_length;
|
||||
|
||||
for (i=0;i<block_length;i++) {
|
||||
#ifdef GENERATE_COMPLEX
|
||||
#ifdef GENESRSLTE_TCOD_RATE_COMPLEX
|
||||
__real__ input[i] = (float) ((i+offset)%(block_length));
|
||||
__imag__ input[i] = (float) ((block_length-i-1+offset)%(block_length));
|
||||
#else
|
||||
|
|
|
@ -120,7 +120,7 @@ int parse_args(prog_args_t *args, int argc, char **argv) {
|
|||
/* TODO: Do something with the output data */
|
||||
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);
|
||||
return cuhd_recv(h, data, nsamples, 1);
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
return cuhd_recv(h, data, nsamples, 1);
|
||||
}
|
||||
|
|
|
@ -43,7 +43,7 @@
|
|||
#ifndef DISABLE_UHD
|
||||
#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);
|
||||
return cuhd_recv(h, data, nsamples, 1);
|
||||
}
|
||||
|
|
|
@ -38,7 +38,7 @@ void usage(char *arg) {
|
|||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
binsource_hl bs;
|
||||
srslte_binsource_hl bs;
|
||||
mod_hl mod;
|
||||
srslte_ch_awgn_hl ch;
|
||||
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.sigma = var;
|
||||
|
||||
if ( binsource_initialize(&bs) ||
|
||||
if ( srslte_binsource_initialize(&bs) ||
|
||||
mod_initialize(&mod) ||
|
||||
srslte_ch_awgn_initialize(&ch) ||
|
||||
demod_hard_initialize(&demod_h) ||
|
||||
|
@ -96,7 +96,7 @@ int main(int argc, char **argv) {
|
|||
exit(-1);
|
||||
}
|
||||
|
||||
binsource_work(&bs);
|
||||
srslte_binsource_work(&bs);
|
||||
mod_work(&mod);
|
||||
srslte_ch_awgn_work(&ch);
|
||||
demod_hard_work(&demod_h);
|
||||
|
|
|
@ -32,15 +32,15 @@
|
|||
#include "srslte/srslte.h"
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
binsource_t bs;
|
||||
srslte_binsource_t bs;
|
||||
uint8_t* output;
|
||||
|
||||
binsource_init(&bs);
|
||||
binsource_seed_time(&bs);
|
||||
srslte_binsource_init(&bs);
|
||||
srslte_binsource_seed_time(&bs);
|
||||
|
||||
output = malloc(100);
|
||||
|
||||
if (binsource_generate(&bs,output,100)) {
|
||||
if (srslte_binsource_generate(&bs,output,100)) {
|
||||
printf("Error generating bits\n");
|
||||
exit(-1);
|
||||
}
|
||||
|
|
|
@ -68,7 +68,7 @@ char *uhd_args = "";
|
|||
float uhd_amp = 0.03, uhd_gain = 70.0, uhd_freq = 2400000000;
|
||||
|
||||
bool null_file_sink=false;
|
||||
filesink_t fsink;
|
||||
srslte_filesink_t fsink;
|
||||
srslte_fft_t ifft;
|
||||
pbch_t pbch;
|
||||
pcfich_t pcfich;
|
||||
|
@ -86,8 +86,8 @@ pthread_t net_thread;
|
|||
void *net_thread_fnc(void *arg);
|
||||
sem_t net_sem;
|
||||
bool net_packet_ready = false;
|
||||
netsource_t net_source;
|
||||
netsink_t net_sink;
|
||||
srslte_netsource_t net_source;
|
||||
srslte_netsink_t net_sink;
|
||||
|
||||
int prbset_num = 1, last_prbset_num = 1;
|
||||
int prbset_orig = 0;
|
||||
|
@ -177,7 +177,7 @@ void base_init() {
|
|||
/* open file or USRP */
|
||||
if (output_file_name) {
|
||||
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);
|
||||
exit(-1);
|
||||
}
|
||||
|
@ -199,12 +199,12 @@ void base_init() {
|
|||
}
|
||||
|
||||
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);
|
||||
exit(-1);
|
||||
}
|
||||
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");
|
||||
exit(-1);
|
||||
}
|
||||
|
@ -277,7 +277,7 @@ void base_free() {
|
|||
}
|
||||
if (output_file_name) {
|
||||
if (!null_file_sink) {
|
||||
filesink_free(&fsink);
|
||||
srslte_filesink_free(&fsink);
|
||||
}
|
||||
} else {
|
||||
#ifndef DISABLE_UHD
|
||||
|
@ -286,7 +286,7 @@ void base_free() {
|
|||
}
|
||||
|
||||
if (net_port > 0) {
|
||||
netsource_free(&net_source);
|
||||
srslte_netsource_free(&net_source);
|
||||
sem_close(&net_sem);
|
||||
}
|
||||
}
|
||||
|
@ -408,7 +408,7 @@ void *net_thread_fnc(void *arg) {
|
|||
int rpm = 0, wpm=0;
|
||||
|
||||
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) {
|
||||
int nbytes = 1+(ra_dl.mcs.tbs-1)/8;
|
||||
rpm += n;
|
||||
|
@ -578,7 +578,7 @@ int main(int argc, char **argv) {
|
|||
if (net_port > 0 && net_packet_ready) {
|
||||
if (null_file_sink) {
|
||||
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");
|
||||
}
|
||||
}
|
||||
|
@ -596,7 +596,7 @@ int main(int argc, char **argv) {
|
|||
/* send to file or usrp */
|
||||
if (output_file_name) {
|
||||
if (!null_file_sink) {
|
||||
filesink_write(&fsink, output_buffer, sf_n_samples);
|
||||
srslte_filesink_write(&fsink, output_buffer, sf_n_samples);
|
||||
}
|
||||
usleep(1000);
|
||||
} else {
|
||||
|
|
|
@ -208,7 +208,7 @@ void sig_int_handler(int signo)
|
|||
}
|
||||
|
||||
#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);
|
||||
return cuhd_recv(h, data, nsamples, 1);
|
||||
}
|
||||
|
@ -224,7 +224,7 @@ prog_args_t prog_args;
|
|||
|
||||
uint32_t sfn = 0; // system frame number
|
||||
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 ret;
|
||||
|
@ -242,18 +242,18 @@ int main(int argc, char **argv) {
|
|||
parse_args(&prog_args, argc, argv);
|
||||
|
||||
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);
|
||||
exit(-1);
|
||||
}
|
||||
netsink_set_nonblocking(&net_sink);
|
||||
srslte_netsink_set_nonblocking(&net_sink);
|
||||
}
|
||||
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);
|
||||
exit(-1);
|
||||
}
|
||||
netsink_set_nonblocking(&net_sink_signal);
|
||||
srslte_netsink_set_nonblocking(&net_sink_signal);
|
||||
}
|
||||
|
||||
#ifndef DISABLE_UHD
|
||||
|
@ -409,7 +409,7 @@ int main(int argc, char **argv) {
|
|||
/* Send data if socket active */
|
||||
if (prog_args.net_port > 0) {
|
||||
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++;
|
||||
|
@ -563,7 +563,7 @@ void *plot_thread_run(void *arg) {
|
|||
|
||||
if (plot_sf_idx == 1) {
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
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;
|
||||
ra_pusch_t ra_pusch;
|
||||
uint32_t rar_window_start = 0, rar_trials = 0, rar_window_stop = 0;
|
||||
timestamp_t uhd_time;
|
||||
timestamp_t next_tx_time;
|
||||
srslte_timestamp_t uhd_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};
|
||||
uint8_t data[1000];
|
||||
cf_t *prach_buffer;
|
||||
|
@ -399,7 +399,7 @@ int main(int argc, char **argv) {
|
|||
bzero(&drms_cfg, sizeof(srslte_refsignal_drms_pusch_cfg_t));
|
||||
drms_cfg.beta_pusch = 1.0;
|
||||
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.cyclic_shift = 0;
|
||||
drms_cfg.cyclic_shift_for_drms = 0;
|
||||
|
@ -451,7 +451,7 @@ int main(int argc, char **argv) {
|
|||
}
|
||||
#else
|
||||
ret = 1;
|
||||
timestamp_t rx_time, tx_time;
|
||||
srslte_timestamp_t rx_time, tx_time;
|
||||
cf_t dummy[4];
|
||||
#endif
|
||||
|
||||
|
@ -490,10 +490,10 @@ int main(int argc, char **argv) {
|
|||
if (((sfn%2) == 1) && (ue_sync_get_sfidx(&ue_sync) == 1)) {
|
||||
ue_sync_get_last_timestamp(&ue_sync, &uhd_time);
|
||||
|
||||
timestamp_copy(&next_tx_time, &uhd_time);
|
||||
timestamp_add(&next_tx_time, 0, 0.01); // send next frame (10 ms)
|
||||
srslte_timestamp_copy(&next_tx_time, &uhd_time);
|
||||
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",
|
||||
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,
|
||||
next_tx_time.full_secs, next_tx_time.frac_secs);
|
||||
|
@ -506,11 +506,11 @@ int main(int argc, char **argv) {
|
|||
#else
|
||||
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");
|
||||
vec_save_file("prach_tx", prach_buffers[7], prach_buffer_len*sizeof(cf_t));
|
||||
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,
|
||||
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));
|
||||
|
||||
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_copy(&next_tx_time, &uhd_time);
|
||||
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 "
|
||||
"send PUSCH time = %.6f TA: %.1f us\n",
|
||||
SRSLTE_SF_LEN_PRB(cell.nof_prb), sfn, ra_pusch.rv_idx,
|
||||
timestamp_real(&uhd_time),
|
||||
timestamp_real(&next_tx_time), time_adv_sec*1000000);
|
||||
srslte_timestamp_real(&uhd_time),
|
||||
srslte_timestamp_real(&next_tx_time), time_adv_sec*1000000);
|
||||
|
||||
cuhd_send_timed(uhd, ul_signal, SRSLTE_SF_LEN_PRB(cell.nof_prb),
|
||||
next_tx_time.full_secs, next_tx_time.frac_secs);
|
||||
|
@ -615,9 +615,9 @@ int main(int argc, char **argv) {
|
|||
|
||||
#ifdef use_usrp
|
||||
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) {
|
||||
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),
|
||||
next_tx_time.full_secs, next_tx_time.frac_secs);
|
||||
}
|
||||
|
|
|
@ -101,8 +101,8 @@ void parse_args(int argc, char **argv) {
|
|||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
filesource_t fsrc;
|
||||
filesink_t fsink;
|
||||
srslte_filesource_t fsrc;
|
||||
srslte_filesink_t fsink;
|
||||
pss_synch_t pss[3]; // One for each N_id_2
|
||||
sss_synch_t sss[3]; // One for each N_id_2
|
||||
cfo_t cfocorr;
|
||||
|
@ -128,11 +128,11 @@ int main(int argc, char **argv) {
|
|||
gettimeofday(&tdata[1], NULL);
|
||||
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);
|
||||
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);
|
||||
exit(-1);
|
||||
}
|
||||
|
@ -190,7 +190,7 @@ int main(int argc, char **argv) {
|
|||
|
||||
/* read all file or nof_frames */
|
||||
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) {
|
||||
|
||||
gettimeofday(&tdata[1], NULL);
|
||||
|
@ -259,8 +259,8 @@ int main(int argc, char **argv) {
|
|||
sss_synch_free(&sss[N_id_2]);
|
||||
}
|
||||
|
||||
filesource_free(&fsrc);
|
||||
filesink_free(&fsink);
|
||||
srslte_filesource_free(&fsrc);
|
||||
srslte_filesink_free(&fsink);
|
||||
|
||||
free(input);
|
||||
free(cfo);
|
||||
|
|
|
@ -50,7 +50,7 @@ typedef struct SRSLTE_API {
|
|||
bool en_drms_2;
|
||||
float beta_pusch;
|
||||
bool group_hopping_en;
|
||||
bool sequence_hopping_en;
|
||||
bool srslte_sequence_hopping_en;
|
||||
}srslte_refsignal_drms_pusch_cfg_t;
|
||||
|
||||
typedef struct SRSLTE_API {
|
||||
|
|
|
@ -34,45 +34,45 @@
|
|||
typedef struct SRSLTE_API {
|
||||
uint8_t *c;
|
||||
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 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);
|
||||
|
||||
SRSLTE_API int sequence_pbch(sequence_t *seq,
|
||||
SRSLTE_API int srslte_sequence_pbch(srslte_sequence_t *seq,
|
||||
srslte_cp_t cp,
|
||||
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 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 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 cell_id,
|
||||
uint32_t len);
|
||||
|
||||
SRSLTE_API int sequence_pdsch(sequence_t *seq,
|
||||
unsigned short rnti,
|
||||
SRSLTE_API int srslte_sequence_pdsch(srslte_sequence_t *seq,
|
||||
uint16_t rnti,
|
||||
int q,
|
||||
uint32_t nslot,
|
||||
uint32_t cell_id,
|
||||
uint32_t len);
|
||||
|
||||
SRSLTE_API int sequence_pusch(sequence_t *seq,
|
||||
unsigned short rnti,
|
||||
SRSLTE_API int srslte_sequence_pusch(srslte_sequence_t *seq,
|
||||
uint16_t rnti,
|
||||
uint32_t nslot,
|
||||
uint32_t cell_id,
|
||||
uint32_t len);
|
||||
|
|
|
@ -42,12 +42,23 @@
|
|||
typedef struct SRSLTE_API{
|
||||
time_t full_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 timestamp_copy(timestamp_t *dest, timestamp_t *src);
|
||||
SRSLTE_API int timestamp_add(timestamp_t *t, time_t full_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_init(srslte_timestamp_t *t,
|
||||
time_t full_secs,
|
||||
double frac_secs);
|
||||
|
||||
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_
|
||||
|
|
|
@ -38,15 +38,18 @@ typedef struct SRSLTE_API {
|
|||
uint32_t K;
|
||||
uint32_t poly[3];
|
||||
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 */
|
||||
typedef struct SRSLTE_API {
|
||||
convcoder_t obj;
|
||||
struct convcoder_ctrl_in {
|
||||
srslte_convcoder_t obj;
|
||||
struct srslte_convcoder_ctrl_in {
|
||||
int rate;
|
||||
int constraint_length;
|
||||
int tail_bitting;
|
||||
|
@ -59,10 +62,10 @@ typedef struct SRSLTE_API {
|
|||
int in_len;
|
||||
uint8_t *output;
|
||||
int out_len;
|
||||
}convcoder_hl;
|
||||
}srslte_convcoder_hl;
|
||||
|
||||
SRSLTE_API int convcoder_initialize(convcoder_hl* h);
|
||||
SRSLTE_API int convcoder_work(convcoder_hl* hl);
|
||||
SRSLTE_API int convcoder_stop(convcoder_hl* h);
|
||||
SRSLTE_API int srslte_convcoder_initialize(srslte_convcoder_hl* h);
|
||||
SRSLTE_API int srslte_convcoder_work(srslte_convcoder_hl* hl);
|
||||
SRSLTE_API int srslte_convcoder_stop(srslte_convcoder_hl* h);
|
||||
|
||||
#endif
|
||||
|
|
|
@ -40,12 +40,22 @@ typedef struct SRSLTE_API {
|
|||
unsigned long crcinit;
|
||||
unsigned long crcmask;
|
||||
unsigned long crchighbit;
|
||||
uint32_t crc_out;
|
||||
} crc_t;
|
||||
uint32_t srslte_crc_out;
|
||||
} srslte_crc_t;
|
||||
|
||||
SRSLTE_API int crc_init(crc_t *h, uint32_t crc_poly, int crc_order);
|
||||
SRSLTE_API int crc_set_init(crc_t *h, unsigned long crc_init_value);
|
||||
SRSLTE_API void crc_attach(crc_t *h, uint8_t *data, int len);
|
||||
SRSLTE_API uint32_t crc_checksum(crc_t *h, uint8_t *data, int len);
|
||||
SRSLTE_API int srslte_crc_init(srslte_crc_t *h,
|
||||
uint32_t srslte_crc_poly,
|
||||
int srslte_crc_order);
|
||||
|
||||
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
|
||||
|
|
|
@ -30,19 +30,19 @@
|
|||
|
||||
#include "srslte/config.h"
|
||||
|
||||
#ifndef RX_NULL
|
||||
#define RX_NULL 10000
|
||||
#ifndef SRSLTE_RX_NULL
|
||||
#define SRSLTE_RX_NULL 10000
|
||||
#endif
|
||||
|
||||
#ifndef TX_NULL
|
||||
#define TX_NULL 100
|
||||
#ifndef SRSLTE_TX_NULL
|
||||
#define SRSLTE_TX_NULL 100
|
||||
#endif
|
||||
SRSLTE_API int rm_conv_tx(uint8_t *input,
|
||||
SRSLTE_API int srslte_rm_conv_tx(uint8_t *input,
|
||||
uint32_t in_len,
|
||||
uint8_t *output,
|
||||
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,
|
||||
float *output,
|
||||
uint32_t out_len);
|
||||
|
@ -50,21 +50,23 @@ SRSLTE_API int rm_conv_rx(float *input,
|
|||
/* High-level API */
|
||||
typedef struct
|
||||
SRSLTE_API {
|
||||
struct rm_conv_init {
|
||||
struct srslte_rm_conv_init {
|
||||
int direction;
|
||||
} init;
|
||||
void *input; // input type may be uint8_t or float depending on hard
|
||||
int in_len;
|
||||
struct rm_conv_ctrl_in {
|
||||
struct srslte_rm_conv_ctrl_in {
|
||||
int E;
|
||||
int S;
|
||||
} ctrl_in;
|
||||
void *output;
|
||||
int out_len;
|
||||
} rm_conv_hl;
|
||||
} srslte_rm_conv_hl;
|
||||
|
||||
SRSLTE_API int rm_conv_initialize(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_initialize(srslte_rm_conv_hl* h);
|
||||
|
||||
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
|
||||
|
|
|
@ -30,18 +30,18 @@
|
|||
|
||||
#include "srslte/config.h"
|
||||
|
||||
#ifndef RX_NULL
|
||||
#define RX_NULL 10000
|
||||
#ifndef SRSLTE_RX_NULL
|
||||
#define SRSLTE_RX_NULL 10000
|
||||
#endif
|
||||
|
||||
#ifndef TX_NULL
|
||||
#define TX_NULL 100
|
||||
#ifndef SRSLTE_TX_NULL
|
||||
#define SRSLTE_TX_NULL 100
|
||||
#endif
|
||||
|
||||
#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,
|
||||
uint8_t *input,
|
||||
uint32_t in_len,
|
||||
|
@ -49,7 +49,7 @@ SRSLTE_API int rm_turbo_tx(uint8_t *w_buff,
|
|||
uint32_t out_len,
|
||||
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,
|
||||
float *input,
|
||||
uint32_t in_len,
|
||||
|
@ -61,22 +61,22 @@ SRSLTE_API int rm_turbo_rx(float *w_buff,
|
|||
/* High-level API */
|
||||
typedef struct SRSLTE_API {
|
||||
|
||||
struct rm_turbo_init {
|
||||
struct srslte_rm_turbo_init {
|
||||
int direction;
|
||||
} init;
|
||||
void *input; // input type may be uint8_t or float depending on hard
|
||||
int in_len;
|
||||
struct rm_turbo_ctrl_in {
|
||||
struct srslte_rm_turbo_ctrl_in {
|
||||
int E;
|
||||
int S;
|
||||
int rv_idx;
|
||||
} ctrl_in;
|
||||
void *output;
|
||||
int out_len;
|
||||
} rm_turbo_hl;
|
||||
} srslte_rm_turbo_hl;
|
||||
|
||||
SRSLTE_API int rm_turbo_initialize(rm_turbo_hl* h);
|
||||
SRSLTE_API int rm_turbo_work(rm_turbo_hl* hl);
|
||||
SRSLTE_API int rm_turbo_stop(rm_turbo_hl* hl);
|
||||
SRSLTE_API int srslte_rm_turbo_initialize(srslte_rm_turbo_hl* h);
|
||||
SRSLTE_API int srslte_rm_turbo_work(srslte_rm_turbo_hl* hl);
|
||||
SRSLTE_API int srslte_rm_turbo_stop(srslte_rm_turbo_hl* hl);
|
||||
|
||||
#endif
|
||||
|
|
|
@ -34,12 +34,17 @@ typedef struct SRSLTE_API {
|
|||
uint32_t *forward;
|
||||
uint32_t *reverse;
|
||||
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 tc_interl_UMTS_gen(tc_interl_t *h, uint32_t long_cb);
|
||||
SRSLTE_API int srs_tc_interl_LTE_gen(srs_tc_interl_t *h,
|
||||
uint32_t long_cb);
|
||||
|
||||
SRSLTE_API int tc_interl_init(tc_interl_t *h, uint32_t max_long_cb);
|
||||
SRSLTE_API void tc_interl_free(tc_interl_t *h);
|
||||
SRSLTE_API int srs_tc_interl_UMTS_gen(srs_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
|
||||
|
|
|
@ -31,23 +31,25 @@
|
|||
#include "srslte/config.h"
|
||||
#include "srslte/fec/tc_interl.h"
|
||||
|
||||
#define NUMREGS 3
|
||||
|
||||
#define RATE 3
|
||||
#define TOTALTAIL 12
|
||||
|
||||
#ifndef TX_NULL
|
||||
#define TX_NULL 100
|
||||
#ifndef SRSLTE_TX_NULL
|
||||
#define SRSLTE_TX_NULL 100
|
||||
#endif
|
||||
|
||||
typedef struct SRSLTE_API {
|
||||
uint32_t max_long_cb;
|
||||
tc_interl_t interl;
|
||||
} tcod_t;
|
||||
srs_tc_interl_t interl;
|
||||
} srslte_tcod_t;
|
||||
|
||||
SRSLTE_API int tcod_init(tcod_t *h, uint32_t max_long_cb);
|
||||
SRSLTE_API void tcod_free(tcod_t *h);
|
||||
SRSLTE_API int tcod_encode(tcod_t *h, uint8_t *input, uint8_t *output, uint32_t long_cb);
|
||||
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 srslte_tcod_encode(srslte_tcod_t *h,
|
||||
uint8_t *input,
|
||||
uint8_t *output,
|
||||
uint32_t long_cb);
|
||||
|
||||
#endif
|
||||
|
||||
|
|
|
@ -31,60 +31,50 @@
|
|||
#include "srslte/config.h"
|
||||
#include "srslte/fec/tc_interl.h"
|
||||
|
||||
#define RATE 3
|
||||
#define 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 SRSLTE_TCOD_RATE 3
|
||||
#define SRSLTE_TCOD_TOTALTAIL 12
|
||||
|
||||
#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 {
|
||||
int max_long_cb;
|
||||
llr_t *beta;
|
||||
} map_gen_t;
|
||||
srslte_llr_t *beta;
|
||||
} srslte_map_gen_t;
|
||||
|
||||
typedef struct SRSLTE_API {
|
||||
int max_long_cb;
|
||||
|
||||
map_gen_t dec;
|
||||
srslte_map_gen_t dec;
|
||||
|
||||
llr_t *llr1;
|
||||
llr_t *llr2;
|
||||
llr_t *w;
|
||||
llr_t *syst;
|
||||
llr_t *parity;
|
||||
srslte_llr_t *llr1;
|
||||
srslte_llr_t *llr2;
|
||||
srslte_llr_t *w;
|
||||
srslte_llr_t *syst;
|
||||
srslte_llr_t *parity;
|
||||
|
||||
tc_interl_t interleaver;
|
||||
} tdec_t;
|
||||
srs_tc_interl_t interleaver;
|
||||
} 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);
|
||||
|
||||
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,
|
||||
llr_t * input,
|
||||
SRSLTE_API void srslte_tdec_iteration(srslte_tdec_t * h,
|
||||
srslte_llr_t * input,
|
||||
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,
|
||||
uint32_t long_cb);
|
||||
|
||||
SRSLTE_API int tdec_run_all(tdec_t * h,
|
||||
llr_t * input,
|
||||
SRSLTE_API int srslte_tdec_run_all(srslte_tdec_t * h,
|
||||
srslte_llr_t * input,
|
||||
uint8_t *output,
|
||||
uint32_t nof_iterations,
|
||||
uint32_t long_cb);
|
||||
|
|
|
@ -33,8 +33,11 @@
|
|||
#include "srslte/config.h"
|
||||
|
||||
typedef enum {
|
||||
viterbi_27, viterbi_29, viterbi_37, viterbi_39
|
||||
}viterbi_type_t;
|
||||
SRSLTE_VITERBI_27 = 0,
|
||||
SRSLTE_VITERBI_29,
|
||||
SRSLTE_VITERBI_37,
|
||||
SRSLTE_VITERBI_39
|
||||
}srslte_viterbi_type_t;
|
||||
|
||||
typedef struct SRSLTE_API{
|
||||
void *ptr;
|
||||
|
@ -49,25 +52,25 @@ typedef struct SRSLTE_API{
|
|||
void (*free) (void*);
|
||||
uint8_t *tmp;
|
||||
uint8_t *symbols_uc;
|
||||
}viterbi_t;
|
||||
}srslte_viterbi_t;
|
||||
|
||||
SRSLTE_API int viterbi_init(viterbi_t *q,
|
||||
viterbi_type_t type,
|
||||
SRSLTE_API 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);
|
||||
|
||||
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);
|
||||
|
||||
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,
|
||||
uint8_t *data,
|
||||
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 *data,
|
||||
uint32_t frame_length);
|
||||
|
@ -75,8 +78,8 @@ SRSLTE_API int viterbi_decode_uc(viterbi_t *q,
|
|||
|
||||
/* High-level API */
|
||||
typedef struct SRSLTE_API{
|
||||
viterbi_t obj;
|
||||
struct viterbi_init {
|
||||
srslte_viterbi_t obj;
|
||||
struct srslte_viterbi_init {
|
||||
int rate;
|
||||
int constraint_length;
|
||||
int tail_bitting;
|
||||
|
@ -89,10 +92,10 @@ typedef struct SRSLTE_API{
|
|||
int in_len;
|
||||
uint8_t *output;
|
||||
int out_len;
|
||||
}viterbi_hl;
|
||||
}srslte_viterbi_hl;
|
||||
|
||||
SRSLTE_API int viterbi_initialize(viterbi_hl* h);
|
||||
SRSLTE_API int viterbi_work(viterbi_hl* hl);
|
||||
SRSLTE_API int viterbi_stop(viterbi_hl* h);
|
||||
SRSLTE_API int srslte_viterbi_initialize(srslte_viterbi_hl* h);
|
||||
SRSLTE_API int srslte_viterbi_work(srslte_viterbi_hl* hl);
|
||||
SRSLTE_API int srslte_viterbi_stop(srslte_viterbi_hl* h);
|
||||
|
||||
#endif
|
||||
|
|
|
@ -42,22 +42,22 @@ typedef struct SRSLTE_API {
|
|||
srslte_dft_plan_t dft_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);
|
||||
|
||||
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 *output,
|
||||
uint32_t nof_prb,
|
||||
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 *output,
|
||||
uint32_t nof_prb,
|
||||
|
|
|
@ -46,35 +46,35 @@ typedef struct SRSLTE_API{
|
|||
float **taps; // 2-D filter coefficients
|
||||
float norm; //normalization factor
|
||||
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,
|
||||
uint32_t ntime,
|
||||
uint32_t nfreq,
|
||||
uint32_t sztime,
|
||||
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 nfreq,
|
||||
uint32_t sztime,
|
||||
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,
|
||||
uint32_t time_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,
|
||||
cf_t *output);
|
||||
#endif // FILTER2D_
|
||||
|
|
|
@ -40,32 +40,44 @@ typedef struct SRSLTE_API{
|
|||
int seq_buff_nwords;
|
||||
int seq_cache_nbits;
|
||||
int seq_cache_rp;
|
||||
}binsource_t;
|
||||
}srslte_binsource_t;
|
||||
|
||||
SRSLTE_API void binsource_init(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 binsource_seed_time(binsource_t *q);
|
||||
SRSLTE_API int binsource_cache_gen(binsource_t* q, int nbits);
|
||||
SRSLTE_API void binsource_cache_cpy(binsource_t* q, uint8_t *bits, int nbits);
|
||||
SRSLTE_API int binsource_generate(binsource_t* q, uint8_t *bits, int nbits);
|
||||
SRSLTE_API void srslte_binsource_init(srslte_binsource_t* q);
|
||||
|
||||
SRSLTE_API void srslte_binsource_free(srslte_binsource_t* q);
|
||||
|
||||
SRSLTE_API void srslte_binsource_seed_set(srslte_binsource_t* q,
|
||||
uint32_t seed);
|
||||
|
||||
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 */
|
||||
typedef struct SRSLTE_API {
|
||||
binsource_t obj;
|
||||
struct binsource_init {
|
||||
srslte_binsource_t obj;
|
||||
struct srslte_binsource_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.
|
||||
} init;
|
||||
struct binsource_ctrl_in {
|
||||
struct srslte_binsource_ctrl_in {
|
||||
int nbits; // Number of bits to generate
|
||||
} ctrl_in;
|
||||
uint8_t* output;
|
||||
int out_len;
|
||||
}binsource_hl;
|
||||
}srslte_binsource_hl;
|
||||
|
||||
SRSLTE_API int binsource_initialize(binsource_hl* h);
|
||||
SRSLTE_API int binsource_work( binsource_hl* hl);
|
||||
SRSLTE_API int binsource_stop(binsource_hl* hl);
|
||||
SRSLTE_API int srslte_binsource_initialize(srslte_binsource_hl* h);
|
||||
SRSLTE_API int srslte_binsource_work( srslte_binsource_hl* hl);
|
||||
SRSLTE_API int srslte_binsource_stop(srslte_binsource_hl* hl);
|
||||
|
||||
#endif // BINSOURCE_
|
||||
|
|
|
@ -38,29 +38,34 @@
|
|||
/* Low-level API */
|
||||
typedef struct SRSLTE_API {
|
||||
FILE *f;
|
||||
data_type_t type;
|
||||
}filesink_t;
|
||||
srslte_datatype_t type;
|
||||
} srslte_filesink_t;
|
||||
|
||||
SRSLTE_API int filesink_init(filesink_t *q, char *filename, data_type_t type);
|
||||
SRSLTE_API void filesink_free(filesink_t *q);
|
||||
SRSLTE_API int srslte_filesink_init(srslte_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 */
|
||||
typedef struct SRSLTE_API {
|
||||
filesink_t obj;
|
||||
struct filesink_init {
|
||||
srslte_filesink_t obj;
|
||||
struct srslte_filesink_init {
|
||||
char *file_name;
|
||||
int block_length;
|
||||
int data_type;
|
||||
} init;
|
||||
void* input;
|
||||
int in_len;
|
||||
}filesink_hl;
|
||||
}srslte_filesink_hl;
|
||||
|
||||
SRSLTE_API int filesink_initialize(filesink_hl* h);
|
||||
SRSLTE_API int filesink_work( filesink_hl* hl);
|
||||
SRSLTE_API int filesink_stop(filesink_hl* h);
|
||||
SRSLTE_API int srslte_filesink_initialize(srslte_filesink_hl* h);
|
||||
SRSLTE_API int srslte_filesink_work( srslte_filesink_hl* hl);
|
||||
SRSLTE_API int srslte_filesink_stop(srslte_filesink_hl* h);
|
||||
|
||||
#endif // FILESINK_
|
||||
|
|
|
@ -38,33 +38,40 @@
|
|||
/* Low-level API */
|
||||
typedef struct SRSLTE_API {
|
||||
FILE *f;
|
||||
data_type_t type;
|
||||
}filesource_t;
|
||||
srslte_datatype_t type;
|
||||
} srslte_filesource_t;
|
||||
|
||||
SRSLTE_API int filesource_init(filesource_t *q, char *filename, data_type_t type);
|
||||
SRSLTE_API void filesource_free(filesource_t *q);
|
||||
SRSLTE_API int srslte_filesource_init(srslte_filesource_t *q,
|
||||
char *filename,
|
||||
srslte_datatype_t type);
|
||||
|
||||
SRSLTE_API void filesource_seek(filesource_t *q, int pos);
|
||||
SRSLTE_API int filesource_read(filesource_t *q, void *buffer, int nsamples);
|
||||
SRSLTE_API void srslte_filesource_free(srslte_filesource_t *q);
|
||||
|
||||
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 */
|
||||
typedef struct SRSLTE_API {
|
||||
filesource_t obj;
|
||||
struct filesource_init {
|
||||
srslte_filesource_t obj;
|
||||
struct srslte_filesource_init {
|
||||
char *file_name;
|
||||
int block_length;
|
||||
int data_type;
|
||||
} init;
|
||||
struct filesource_ctrl_in {
|
||||
struct srslte_filesource_ctrl_in {
|
||||
int nsamples; // Number of samples to read
|
||||
} ctrl_in;
|
||||
void* output;
|
||||
int out_len;
|
||||
}filesource_hl;
|
||||
}srslte_filesource_hl;
|
||||
|
||||
SRSLTE_API int filesource_initialize(filesource_hl* h);
|
||||
SRSLTE_API int filesource_work( filesource_hl* hl);
|
||||
SRSLTE_API int filesource_stop(filesource_hl* h);
|
||||
SRSLTE_API int srslte_filesource_initialize(srslte_filesource_hl* h);
|
||||
SRSLTE_API int srslte_filesource_work( srslte_filesource_hl* hl);
|
||||
SRSLTE_API int srslte_filesource_stop(srslte_filesource_hl* h);
|
||||
|
||||
#endif // FILESOURCE_
|
||||
|
|
|
@ -29,6 +29,13 @@
|
|||
#ifndef 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_
|
||||
|
|
|
@ -38,34 +38,37 @@
|
|||
|
||||
#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 */
|
||||
typedef struct SRSLTE_API {
|
||||
int sockfd;
|
||||
bool connected;
|
||||
netsink_type_t type;
|
||||
srslte_netsink_type_t type;
|
||||
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,
|
||||
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,
|
||||
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 */
|
||||
typedef struct SRSLTE_API {
|
||||
netsink_t obj;
|
||||
struct netsink_init {
|
||||
srslte_netsink_t obj;
|
||||
struct srslte_netsink_init {
|
||||
char *address;
|
||||
int port;
|
||||
int block_length;
|
||||
|
@ -73,10 +76,10 @@ typedef struct SRSLTE_API {
|
|||
} init;
|
||||
void* input;
|
||||
int in_len;
|
||||
}netsink_hl;
|
||||
}srslte_netsink_hl;
|
||||
|
||||
SRSLTE_API int netsink_initialize(netsink_hl* h);
|
||||
SRSLTE_API int netsink_work( netsink_hl* hl);
|
||||
SRSLTE_API int netsink_stop(netsink_hl* h);
|
||||
SRSLTE_API int srslte_netsink_initialize(srslte_netsink_hl* h);
|
||||
SRSLTE_API int srslte_netsink_work( srslte_netsink_hl* hl);
|
||||
SRSLTE_API int srslte_netsink_stop(srslte_netsink_hl* h);
|
||||
|
||||
#endif // UDPSINK_
|
||||
|
|
|
@ -38,51 +38,54 @@
|
|||
|
||||
#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 */
|
||||
typedef struct SRSLTE_API {
|
||||
int sockfd;
|
||||
int connfd;
|
||||
struct sockaddr_in servaddr;
|
||||
netsource_type_t type;
|
||||
srslte_netsource_type_t type;
|
||||
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,
|
||||
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,
|
||||
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);
|
||||
|
||||
|
||||
/* High-level API */
|
||||
typedef struct SRSLTE_API {
|
||||
netsource_t obj;
|
||||
struct netsource_init {
|
||||
srslte_netsource_t obj;
|
||||
struct srslte_netsource_init {
|
||||
char *address;
|
||||
int port;
|
||||
int data_type;
|
||||
} init;
|
||||
struct netsource_ctrl_in {
|
||||
struct srslte_netsource_ctrl_in {
|
||||
int nsamples; // Number of samples to read
|
||||
} ctrl_in;
|
||||
void* output;
|
||||
int out_len;
|
||||
}netsource_hl;
|
||||
}srslte_netsource_hl;
|
||||
|
||||
SRSLTE_API int netsource_initialize(netsource_hl* h);
|
||||
SRSLTE_API int netsource_work( netsource_hl* hl);
|
||||
SRSLTE_API int netsource_stop(netsource_hl* h);
|
||||
SRSLTE_API int srslte_netsource_initialize(srslte_netsource_hl* h);
|
||||
SRSLTE_API int srslte_netsource_work( srslte_netsource_hl* hl);
|
||||
SRSLTE_API int srslte_netsource_stop(srslte_netsource_hl* h);
|
||||
|
||||
#endif // UDPSOURCE_
|
||||
|
|
|
@ -30,26 +30,59 @@
|
|||
#define LAYERMAP_H_
|
||||
|
||||
#include "srslte/config.h"
|
||||
#include "srslte/common/phy_common.h"
|
||||
|
||||
typedef _Complex float cf_t;
|
||||
|
||||
/* 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 layermap_diversity(cf_t *d, cf_t *x[SRSLTE_MAX_LAYERS], int nof_layers, int nof_symbols);
|
||||
SRSLTE_API int layermap_multiplex(cf_t *d[SRSLTE_MAX_CODEWORDS], cf_t *x[SRSLTE_MAX_LAYERS], int nof_cw, int nof_layers,
|
||||
SRSLTE_API int srslte_layermap_single(cf_t *d,
|
||||
cf_t *x,
|
||||
int nof_symbols);
|
||||
|
||||
SRSLTE_API int srslte_layermap_diversity(cf_t *d,
|
||||
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 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);
|
||||
|
||||
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"
|
||||
*/
|
||||
SRSLTE_API int layerdemap_single(cf_t *x, cf_t *d, int nof_symbols);
|
||||
SRSLTE_API int layerdemap_diversity(cf_t *x[SRSLTE_MAX_LAYERS], cf_t *d, int nof_layers, int nof_layer_symbols);
|
||||
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_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,
|
||||
int nof_layer_symbols, int nof_symbols[SRSLTE_MAX_CODEWORDS], srslte_mimo_type_t type);
|
||||
SRSLTE_API int srslte_layerdemap_single(cf_t *x,
|
||||
cf_t *d,
|
||||
int nof_symbols);
|
||||
|
||||
SRSLTE_API int srslte_layerdemap_diversity(cf_t *x[SRSLTE_MAX_LAYERS],
|
||||
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_
|
||||
|
|
|
@ -123,12 +123,12 @@ SRSLTE_API 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);
|
||||
bool srslte_crc_is_crnti);
|
||||
|
||||
SRSLTE_API 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);
|
||||
|
||||
SRSLTE_API uint32_t dci_format_sizeof(dci_format_t format,
|
||||
uint32_t nof_prb);
|
||||
|
|
|
@ -73,10 +73,10 @@ typedef struct SRSLTE_API {
|
|||
/* tx & rx objects */
|
||||
modem_table_t mod;
|
||||
demod_soft_t demod;
|
||||
sequence_t seq_pbch;
|
||||
viterbi_t decoder;
|
||||
crc_t crc;
|
||||
convcoder_t encoder;
|
||||
srslte_sequence_t seq_pbch;
|
||||
srslte_viterbi_t decoder;
|
||||
srslte_crc_t crc;
|
||||
srslte_convcoder_t encoder;
|
||||
precoding_t precoding;
|
||||
|
||||
} pbch_t;
|
||||
|
|
|
@ -68,7 +68,7 @@ typedef struct SRSLTE_API {
|
|||
/* tx & rx objects */
|
||||
modem_table_t mod;
|
||||
demod_soft_t demod;
|
||||
sequence_t seq_pcfich[SRSLTE_NSUBFRAMES_X_FRAME];
|
||||
srslte_sequence_t seq_pcfich[SRSLTE_NSUBFRAMES_X_FRAME];
|
||||
precoding_t precoding;
|
||||
|
||||
} pcfich_t;
|
||||
|
|
|
@ -71,9 +71,9 @@ typedef struct SRSLTE_API {
|
|||
/* tx & rx objects */
|
||||
modem_table_t mod;
|
||||
demod_soft_t demod;
|
||||
sequence_t seq_pdcch[SRSLTE_NSUBFRAMES_X_FRAME];
|
||||
viterbi_t decoder;
|
||||
crc_t crc;
|
||||
srslte_sequence_t seq_pdcch[SRSLTE_NSUBFRAMES_X_FRAME];
|
||||
srslte_viterbi_t decoder;
|
||||
srslte_crc_t crc;
|
||||
precoding_t precoding;
|
||||
|
||||
} pdcch_t;
|
||||
|
@ -107,7 +107,7 @@ SRSLTE_API int pdcch_decode_msg(pdcch_t *q,
|
|||
dci_msg_t *msg,
|
||||
dci_location_t *location,
|
||||
dci_format_t format,
|
||||
uint16_t *crc_rem);
|
||||
uint16_t *srslte_crc_rem);
|
||||
|
||||
/* Function for generation of UE-specific search space DCI locations */
|
||||
SRSLTE_API uint32_t pdcch_ue_locations(pdcch_t *q,
|
||||
|
|
|
@ -64,7 +64,7 @@ typedef struct SRSLTE_API {
|
|||
/* tx & rx objects */
|
||||
modem_table_t mod[4];
|
||||
demod_soft_t demod;
|
||||
sequence_t seq_pdsch[SRSLTE_NSUBFRAMES_X_FRAME];
|
||||
srslte_sequence_t seq_pdsch[SRSLTE_NSUBFRAMES_X_FRAME];
|
||||
precoding_t precoding;
|
||||
|
||||
sch_t dl_sch;
|
||||
|
|
|
@ -74,7 +74,7 @@ typedef struct SRSLTE_API {
|
|||
/* tx & rx objects */
|
||||
modem_table_t mod;
|
||||
demod_hard_t demod;
|
||||
sequence_t seq_phich[SRSLTE_NSUBFRAMES_X_FRAME];
|
||||
srslte_sequence_t seq_phich[SRSLTE_NSUBFRAMES_X_FRAME];
|
||||
precoding_t precoding;
|
||||
|
||||
}phich_t;
|
||||
|
|
|
@ -67,7 +67,7 @@ typedef struct SRSLTE_API {
|
|||
bool rnti_is_set;
|
||||
uint16_t rnti;
|
||||
|
||||
dft_precoding_t dft_precoding;
|
||||
srslte_srslte_dft_precoding_t srslte_dft_precoding;
|
||||
|
||||
precoding_t equalizer;
|
||||
|
||||
|
@ -83,8 +83,8 @@ typedef struct SRSLTE_API {
|
|||
/* tx & rx objects */
|
||||
modem_table_t mod[4];
|
||||
demod_soft_t demod;
|
||||
sequence_t seq_pusch[SRSLTE_NSUBFRAMES_X_FRAME];
|
||||
sequence_t seq_type2_fo;
|
||||
srslte_sequence_t seq_pusch[SRSLTE_NSUBFRAMES_X_FRAME];
|
||||
srslte_sequence_t seq_type2_fo;
|
||||
|
||||
sch_t dl_sch;
|
||||
|
||||
|
|
|
@ -41,12 +41,12 @@
|
|||
#define TDEC_MAX_ITERATIONS 5
|
||||
|
||||
|
||||
#ifndef RX_NULL
|
||||
#define RX_NULL 10000
|
||||
#ifndef SRSLTE_RX_NULL
|
||||
#define SRSLTE_RX_NULL 10000
|
||||
#endif
|
||||
|
||||
#ifndef TX_NULL
|
||||
#define TX_NULL 100
|
||||
#ifndef SRSLTE_TX_NULL
|
||||
#define SRSLTE_TX_NULL 100
|
||||
#endif
|
||||
|
||||
/* DL-SCH AND UL-SCH common functions */
|
||||
|
@ -60,10 +60,10 @@ typedef struct SRSLTE_API {
|
|||
void *cb_out;
|
||||
void *pdsch_e;
|
||||
|
||||
tcod_t encoder;
|
||||
tdec_t decoder;
|
||||
crc_t crc_tb;
|
||||
crc_t crc_cb;
|
||||
srslte_tcod_t encoder;
|
||||
srslte_tdec_t decoder;
|
||||
srslte_crc_t srslte_crc_tb;
|
||||
srslte_crc_t srslte_crc_cb;
|
||||
|
||||
uci_cqi_pusch_t uci_cqi;
|
||||
|
||||
|
|
|
@ -40,7 +40,7 @@
|
|||
|
||||
|
||||
typedef struct SRSLTE_API {
|
||||
crc_t crc;
|
||||
srslte_crc_t crc;
|
||||
uint8_t tmp_cqi[MAX_CQI_LEN_PUSCH];
|
||||
uint8_t encoded_cqi[3*MAX_CQI_LEN_PUSCH];
|
||||
} uci_cqi_pusch_t;
|
||||
|
|
|
@ -36,31 +36,31 @@
|
|||
typedef _Complex float cf_t;
|
||||
|
||||
/* Scrambling has no state */
|
||||
SRSLTE_API void scrambling_b(sequence_t *s,
|
||||
SRSLTE_API void scrambling_b(srslte_sequence_t *s,
|
||||
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,
|
||||
int offset,
|
||||
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,
|
||||
int offset,
|
||||
int len);
|
||||
|
||||
SRSLTE_API void scrambling_f(sequence_t *s,
|
||||
SRSLTE_API void scrambling_f(srslte_sequence_t *s,
|
||||
float *data);
|
||||
|
||||
SRSLTE_API void scrambling_f_offset(sequence_t *s,
|
||||
SRSLTE_API void scrambling_f_offset(srslte_sequence_t *s,
|
||||
float *data,
|
||||
int offset,
|
||||
int len);
|
||||
|
||||
SRSLTE_API void scrambling_c(sequence_t *s,
|
||||
SRSLTE_API void scrambling_c(srslte_sequence_t *s,
|
||||
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,
|
||||
int offset,
|
||||
int len);
|
||||
|
@ -77,7 +77,7 @@ SRSLTE_API void scrambling_c_offset(sequence_t *s,
|
|||
#define SCRAMBLING_PUCCH 5
|
||||
|
||||
typedef struct SRSLTE_API {
|
||||
sequence_t seq[SRSLTE_NSUBFRAMES_X_FRAME];
|
||||
srslte_sequence_t seq[SRSLTE_NSUBFRAMES_X_FRAME];
|
||||
}scrambling_t;
|
||||
|
||||
typedef struct SRSLTE_API {
|
||||
|
|
|
@ -86,12 +86,12 @@ typedef struct SRSLTE_API {
|
|||
|
||||
|
||||
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);
|
||||
|
||||
SRSLTE_API int ue_cell_search_init_max(ue_cell_search_t *q,
|
||||
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);
|
||||
|
||||
SRSLTE_API void ue_cell_search_free(ue_cell_search_t *q);
|
||||
|
|
|
@ -104,7 +104,7 @@ typedef struct {
|
|||
SRSLTE_API int ue_mib_sync_init(ue_mib_sync_t *q,
|
||||
uint32_t cell_id,
|
||||
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);
|
||||
|
||||
SRSLTE_API void ue_mib_sync_free(ue_mib_sync_t *q);
|
||||
|
|
|
@ -118,12 +118,12 @@ public:
|
|||
public:
|
||||
dl_tb(uint32_t max_dlsch_bits);
|
||||
uint16_t get_rnti();
|
||||
bool is_crc_valid();
|
||||
bool is_srslte_crc_valid();
|
||||
uint8_t* get_dlsch_payload();
|
||||
private:
|
||||
uint8_t* dlsch_buffer;
|
||||
uint16_t rnti;
|
||||
bool crc_result;
|
||||
bool srslte_crc_result;
|
||||
};
|
||||
|
||||
class dl_grant : public queue::element {
|
||||
|
|
|
@ -65,10 +65,10 @@ typedef struct SRSLTE_API {
|
|||
sync_t strack;
|
||||
|
||||
void *stream;
|
||||
int (*recv_callback)(void*, void*, uint32_t, timestamp_t*);
|
||||
timestamp_t last_timestamp;
|
||||
int (*recv_callback)(void*, void*, uint32_t, srslte_timestamp_t*);
|
||||
srslte_timestamp_t last_timestamp;
|
||||
|
||||
filesource_t file_source;
|
||||
srslte_filesource_t file_source;
|
||||
bool file_mode;
|
||||
|
||||
ue_sync_state_t state;
|
||||
|
@ -107,7 +107,7 @@ typedef struct SRSLTE_API {
|
|||
|
||||
SRSLTE_API int ue_sync_init(ue_sync_t *q,
|
||||
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);
|
||||
|
||||
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 void ue_sync_get_last_timestamp(ue_sync_t *q,
|
||||
timestamp_t *timestamp);
|
||||
srslte_timestamp_t *timestamp);
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -109,7 +109,7 @@ int srslte_refsignal_cs_init(srslte_refsignal_cs_t * q, srslte_cell_t cell)
|
|||
uint32_t c_init;
|
||||
uint32_t i, ns, l, p;
|
||||
uint32_t N_cp, mp;
|
||||
sequence_t seq;
|
||||
srslte_sequence_t seq;
|
||||
int ret = SRSLTE_ERROR_INVALID_INPUTS;
|
||||
|
||||
if (q != NULL &&
|
||||
|
@ -118,8 +118,8 @@ int srslte_refsignal_cs_init(srslte_refsignal_cs_t * q, srslte_cell_t cell)
|
|||
ret = SRSLTE_ERROR;
|
||||
|
||||
bzero(q, sizeof(srslte_refsignal_cs_t));
|
||||
bzero(&seq, sizeof(sequence_t));
|
||||
if (sequence_init(&seq, 2 * 2 * SRSLTE_MAX_PRB)) {
|
||||
bzero(&seq, sizeof(srslte_sequence_t));
|
||||
if (srslte_sequence_init(&seq, 2 * 2 * SRSLTE_MAX_PRB)) {
|
||||
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;
|
||||
|
||||
/* generate sequence for this symbol and slot */
|
||||
sequence_set_LTE_pr(&seq, c_init);
|
||||
srslte_sequence_set_LTE_pr(&seq, c_init);
|
||||
|
||||
/* Compute signal */
|
||||
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;
|
||||
}
|
||||
free_and_exit:
|
||||
if (ret == SRSLTE_ERROR) {
|
||||
sequence_free(&seq);
|
||||
srslte_sequence_free(&seq);
|
||||
srslte_refsignal_cs_free(q);
|
||||
}
|
||||
return ret;
|
||||
|
|
|
@ -68,12 +68,12 @@ static int generate_n_prs(srslte_refsignal_ul_t * q) {
|
|||
/* Calculate n_prs */
|
||||
uint32_t c_init;
|
||||
|
||||
sequence_t seq;
|
||||
bzero(&seq, sizeof(sequence_t));
|
||||
srslte_sequence_t seq;
|
||||
bzero(&seq, sizeof(srslte_sequence_t));
|
||||
|
||||
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);
|
||||
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;
|
||||
}
|
||||
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;
|
||||
}
|
||||
|
||||
/** 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) {
|
||||
sequence_t seq;
|
||||
bzero(&seq, sizeof(sequence_t));
|
||||
srslte_sequence_t seq;
|
||||
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;
|
||||
}
|
||||
|
||||
|
@ -106,23 +106,23 @@ static int generate_group_hopping_f_gh(srslte_refsignal_ul_t *q) {
|
|||
q->f_gh[ns] = f_gh;
|
||||
}
|
||||
|
||||
sequence_free(&seq);
|
||||
srslte_sequence_free(&seq);
|
||||
return SRSLTE_SUCCESS;
|
||||
}
|
||||
|
||||
static int generate_sequence_hopping_v(srslte_refsignal_ul_t *q) {
|
||||
sequence_t seq;
|
||||
bzero(&seq, sizeof(sequence_t));
|
||||
static int generate_srslte_sequence_hopping_v(srslte_refsignal_ul_t *q) {
|
||||
srslte_sequence_t seq;
|
||||
bzero(&seq, sizeof(srslte_sequence_t));
|
||||
|
||||
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++) {
|
||||
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;
|
||||
}
|
||||
q->v_pusch[ns][delta_ss] = seq.c[ns];
|
||||
}
|
||||
}
|
||||
sequence_free(&seq);
|
||||
srslte_sequence_free(&seq);
|
||||
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
|
||||
if (generate_sequence_hopping_v(q)) {
|
||||
if (generate_srslte_sequence_hopping_v(q)) {
|
||||
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
|
||||
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];
|
||||
}
|
||||
|
||||
|
|
|
@ -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));
|
||||
} else {
|
||||
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) {
|
||||
|
|
|
@ -77,13 +77,13 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
|
|||
|
||||
|
||||
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");
|
||||
if (tmp) {
|
||||
if (!strcmp(tmp, "Group")) {
|
||||
pusch_cfg.group_hopping_en = true;
|
||||
} else if (!strcmp(tmp, "Sequence")) {
|
||||
pusch_cfg.sequence_hopping_en = true;
|
||||
pusch_cfg.srslte_sequence_hopping_en = true;
|
||||
}
|
||||
mxFree(tmp);
|
||||
}
|
||||
|
|
|
@ -108,13 +108,13 @@ int main(int argc, char **argv) {
|
|||
pusch_cfg.delta_ss = delta_ss;
|
||||
if (!h) {
|
||||
pusch_cfg.group_hopping_en = false;
|
||||
pusch_cfg.sequence_hopping_en = false;
|
||||
pusch_cfg.srslte_sequence_hopping_en = false;
|
||||
} else if (h == 1) {
|
||||
pusch_cfg.group_hopping_en = false;
|
||||
pusch_cfg.sequence_hopping_en = true;
|
||||
pusch_cfg.srslte_sequence_hopping_en = true;
|
||||
} else if (h == 2) {
|
||||
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;
|
||||
printf("Beta: %f, ",pusch_cfg.beta_pusch);
|
||||
|
|
|
@ -40,7 +40,7 @@
|
|||
* It follows the 3GPP Release 8 (LTE) 36.211
|
||||
* 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;
|
||||
uint32_t *x1, *x2;
|
||||
|
||||
|
@ -74,16 +74,16 @@ void sequence_set_LTE_pr(sequence_t *q, uint32_t seed) {
|
|||
free(x2);
|
||||
}
|
||||
|
||||
int sequence_LTE_pr(sequence_t *q, uint32_t len, uint32_t seed) {
|
||||
if (sequence_init(q, len)) {
|
||||
int srslte_sequence_LTE_pr(srslte_sequence_t *q, uint32_t len, uint32_t seed) {
|
||||
if (srslte_sequence_init(q, len)) {
|
||||
return SRSLTE_ERROR;
|
||||
}
|
||||
q->len = len;
|
||||
sequence_set_LTE_pr(q, seed);
|
||||
srslte_sequence_set_LTE_pr(q, seed);
|
||||
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)) {
|
||||
free(q->c);
|
||||
}
|
||||
|
@ -97,11 +97,11 @@ int sequence_init(sequence_t *q, uint32_t len) {
|
|||
return SRSLTE_SUCCESS;
|
||||
}
|
||||
|
||||
void sequence_free(sequence_t *q) {
|
||||
void srslte_sequence_free(srslte_sequence_t *q) {
|
||||
if (q->c) {
|
||||
free(q->c);
|
||||
}
|
||||
bzero(q, sizeof(sequence_t));
|
||||
bzero(q, sizeof(srslte_sequence_t));
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -28,7 +28,7 @@
|
|||
#include "srslte/common/timestamp.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;
|
||||
if(t != NULL && frac_secs >= 0.0){
|
||||
t->full_secs = full_secs;
|
||||
|
@ -38,7 +38,7 @@ int timestamp_init(timestamp_t *t, time_t full_secs, double frac_secs){
|
|||
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;
|
||||
if(dest != NULL && src != NULL){
|
||||
dest->full_secs = src->full_secs;
|
||||
|
@ -48,7 +48,7 @@ int timestamp_copy(timestamp_t *dest, timestamp_t *src){
|
|||
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;
|
||||
if(t != NULL && frac_secs >= 0.0){
|
||||
t->frac_secs += frac_secs;
|
||||
|
@ -61,7 +61,7 @@ int timestamp_add(timestamp_t *t, time_t full_secs, double frac_secs){
|
|||
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;
|
||||
if(t != NULL && frac_secs >= 0.0){
|
||||
t->frac_secs -= frac_secs;
|
||||
|
@ -77,6 +77,6 @@ int timestamp_sub(timestamp_t *t, time_t full_secs, double frac_secs){
|
|||
return ret;
|
||||
}
|
||||
|
||||
double timestamp_real(timestamp_t *t){
|
||||
double srslte_timestamp_real(srslte_timestamp_t *t){
|
||||
return t->frac_secs + t->full_secs;
|
||||
}
|
||||
|
|
|
@ -34,7 +34,7 @@
|
|||
#include "srslte/fec/convcoder.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 i,j;
|
||||
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;
|
||||
}
|
||||
|
||||
int convcoder_work(convcoder_hl* hl) {
|
||||
int srslte_convcoder_work(srslte_convcoder_hl* hl) {
|
||||
|
||||
hl->obj.K = hl->ctrl_in.constraint_length;
|
||||
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[2] = hl->ctrl_in.generator_2;
|
||||
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;
|
||||
}
|
||||
|
||||
int convcoder_stop(convcoder_hl* h) {
|
||||
int srslte_convcoder_stop(srslte_convcoder_hl* h) {
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -32,7 +32,7 @@
|
|||
#include "srslte/utils/pack.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);
|
||||
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.
|
||||
int ord = h->order - 8;
|
||||
|
@ -61,7 +61,7 @@ unsigned long crctable(crc_t *h) {
|
|||
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;
|
||||
|
||||
|
@ -74,21 +74,21 @@ unsigned long reversecrcbit(uint32_t crc, int nbits, crc_t *h) {
|
|||
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;
|
||||
if (crc_par->crcinit != (crc_par->crcinit & crc_par->crcmask)) {
|
||||
printf("ERROR, invalid crcinit in crc_set_init().\n");
|
||||
srslte_crc_par->crcinit = srslte_crc_init_value;
|
||||
if (srslte_crc_par->crcinit != (srslte_crc_par->crcinit & srslte_crc_par->crcmask)) {
|
||||
printf("ERROR, invalid crcinit in srslte_crc_set_init().\n");
|
||||
return -1;
|
||||
}
|
||||
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
|
||||
h->polynom = crc_poly;
|
||||
h->order = crc_order;
|
||||
h->polynom = srslte_crc_poly;
|
||||
h->order = srslte_crc_order;
|
||||
h->crcinit = 0x00000000;
|
||||
|
||||
// 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;
|
||||
}
|
||||
|
||||
if (crc_set_init(h, h->crcinit)) {
|
||||
if (srslte_crc_set_init(h, h->crcinit)) {
|
||||
fprintf(stderr, "Error setting CRC init word\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
// generate lookup table
|
||||
gen_crc_table(h);
|
||||
gen_srslte_crc_table(h);
|
||||
|
||||
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;
|
||||
uint32_t crc = 0;
|
||||
uint8_t *pter;
|
||||
|
||||
crc_set_init(h, 0);
|
||||
srslte_crc_set_init(h, 0);
|
||||
|
||||
// Pack bits into bytes
|
||||
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.
|
||||
* The buffer data must be len + crc_order bytes
|
||||
/** Appends srslte_crc_order checksum bits to the buffer data.
|
||||
* The buffer data must be len + srslte_crc_order bytes
|
||||
*/
|
||||
void crc_attach(crc_t *h, uint8_t *data, int len) {
|
||||
uint32_t checksum = crc_checksum(h, data, len);
|
||||
void srslte_crc_attach(srslte_crc_t *h, uint8_t *data, int len) {
|
||||
uint32_t checksum = srslte_crc_checksum(h, data, len);
|
||||
|
||||
// Add CRC
|
||||
uint8_t *ptr = &data[len];
|
||||
|
|
|
@ -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,
|
||||
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];
|
||||
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 (i = 0; i < nrows; i++) {
|
||||
if (i * NCOLS + RM_PERM_CC[j] < ndummy) {
|
||||
tmp[k] = TX_NULL;
|
||||
tmp[k] = SRSLTE_TX_NULL;
|
||||
} else {
|
||||
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;
|
||||
j = 0;
|
||||
while (k < out_len) {
|
||||
if (tmp[j] != TX_NULL) {
|
||||
if (tmp[j] != SRSLTE_TX_NULL) {
|
||||
output[k] = tmp[j];
|
||||
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.
|
||||
* 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 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++) {
|
||||
tmp[i] = RX_NULL;
|
||||
tmp[i] = SRSLTE_RX_NULL;
|
||||
}
|
||||
|
||||
/* 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;
|
||||
|
||||
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];
|
||||
} else if (input[k] != RX_NULL) {
|
||||
} else if (input[k] != SRSLTE_RX_NULL) {
|
||||
tmp[j] += input[k]; /* soft combine LLRs */
|
||||
}
|
||||
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;
|
||||
for (j = 0; j < 3; j++) {
|
||||
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;
|
||||
} else {
|
||||
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 */
|
||||
|
||||
int rm_conv_initialize(rm_conv_hl* h) {
|
||||
int srslte_rm_conv_initialize(srslte_rm_conv_hl* h) {
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/** 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) {
|
||||
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;
|
||||
} 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;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int rm_conv_stop(rm_conv_hl* hl) {
|
||||
int srslte_rm_conv_stop(srslte_rm_conv_hl* hl) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -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
|
||||
*/
|
||||
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) {
|
||||
|
||||
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);
|
||||
}
|
||||
if (i * NCOLS + RM_PERM_TC[j] < ndummy) {
|
||||
w_buff[kidx] = TX_NULL;
|
||||
w_buff[kidx] = SRSLTE_TX_NULL;
|
||||
} else {
|
||||
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++) {
|
||||
kidx = (RM_PERM_TC[k / nrows] + NCOLS * (k % nrows) + 1) % K_p;
|
||||
if ((kidx - ndummy) < 0) {
|
||||
w_buff[K_p + 2 * k + 1] = TX_NULL;
|
||||
w_buff[K_p + 2 * k + 1] = SRSLTE_TX_NULL;
|
||||
} else {
|
||||
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;
|
||||
|
||||
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];
|
||||
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
|
||||
* 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) {
|
||||
|
||||
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) {
|
||||
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 (w_buff[jp] == RX_NULL) {
|
||||
if (w_buff[jp] == SRSLTE_RX_NULL) {
|
||||
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 */
|
||||
}
|
||||
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 = 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];
|
||||
} else {
|
||||
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 */
|
||||
|
||||
int rm_turbo_initialize(rm_turbo_hl* h) {
|
||||
int srslte_rm_turbo_initialize(srslte_rm_turbo_hl* h) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/** 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;
|
||||
}
|
||||
|
||||
int rm_turbo_stop(rm_turbo_hl* hl) {
|
||||
int srslte_rm_turbo_stop(srslte_rm_turbo_hl* hl) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -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,
|
||||
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;
|
||||
uint64_t i, j;
|
||||
|
||||
|
|
|
@ -33,7 +33,7 @@
|
|||
#include "srslte/fec/tc_interl.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);
|
||||
|
||||
|
@ -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,
|
||||
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;
|
||||
h->forward = malloc(sizeof(uint32_t) * max_long_cb);
|
||||
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;
|
||||
ret = 0;
|
||||
clean_exit: if (ret == -1) {
|
||||
tc_interl_free(h);
|
||||
srs_tc_interl_free(h);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void tc_interl_free(tc_interl_t *h) {
|
||||
void srs_tc_interl_free(srs_tc_interl_t *h) {
|
||||
if (h->forward) {
|
||||
free(h->forward);
|
||||
}
|
||||
if (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 res, prim, aux;
|
||||
|
|
|
@ -33,21 +33,25 @@
|
|||
|
||||
#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;
|
||||
}
|
||||
h->max_long_cb = max_long_cb;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void tcod_free(tcod_t *h) {
|
||||
tc_interl_free(&h->interl);
|
||||
void srslte_tcod_free(srslte_tcod_t *h) {
|
||||
srs_tc_interl_free(&h->interl);
|
||||
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;
|
||||
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;
|
||||
}
|
||||
|
||||
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");
|
||||
return -1;
|
||||
}
|
||||
|
@ -78,7 +82,7 @@ int tcod_encode(tcod_t *h, uint8_t *input, uint8_t *output, uint32_t long_cb) {
|
|||
|
||||
k = 0;
|
||||
for (i = 0; i < long_cb; i++) {
|
||||
if (input[i] == TX_NULL) {
|
||||
if (input[i] == SRSLTE_TX_NULL) {
|
||||
bit = 0;
|
||||
} else {
|
||||
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_0 = in;
|
||||
|
||||
if (input[i] == TX_NULL) {
|
||||
output[k] = TX_NULL;
|
||||
if (input[i] == SRSLTE_TX_NULL) {
|
||||
output[k] = SRSLTE_TX_NULL;
|
||||
} else {
|
||||
output[k] = out;
|
||||
}
|
||||
k++;
|
||||
|
||||
bit = input[per[i]];
|
||||
if (bit == TX_NULL) {
|
||||
if (bit == SRSLTE_TX_NULL) {
|
||||
bit = 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -35,20 +35,28 @@
|
|||
#include "srslte/fec/turbodecoder.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
|
||||
* 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)
|
||||
{
|
||||
llr_t m_b[8], new[8], old[8];
|
||||
llr_t x, y, xy;
|
||||
srslte_llr_t m_b[8], new[8], old[8];
|
||||
srslte_llr_t x, y, xy;
|
||||
int k;
|
||||
uint32_t end = long_cb + RATE;
|
||||
llr_t *beta = s->beta;
|
||||
uint32_t end = long_cb + SRSLTE_TCOD_RATE;
|
||||
srslte_llr_t *beta = s->beta;
|
||||
uint32_t 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)
|
||||
{
|
||||
llr_t m_b[8], new[8], old[8], max1[8], max0[8];
|
||||
llr_t m1, m0;
|
||||
llr_t x, y, xy;
|
||||
llr_t out;
|
||||
srslte_llr_t m_b[8], new[8], old[8], max1[8], max0[8];
|
||||
srslte_llr_t m1, m0;
|
||||
srslte_llr_t x, y, xy;
|
||||
srslte_llr_t out;
|
||||
uint32_t k;
|
||||
uint32_t end = long_cb;
|
||||
llr_t *beta = s->beta;
|
||||
srslte_llr_t *beta = s->beta;
|
||||
uint32_t i;
|
||||
|
||||
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));
|
||||
h->beta = vec_malloc(sizeof(llr_t) * (max_long_cb + TOTALTAIL + 1) * NUMSTATES);
|
||||
bzero(h, sizeof(srslte_map_gen_t));
|
||||
h->beta = vec_malloc(sizeof(srslte_llr_t) * (max_long_cb + SRSLTE_TCOD_TOTALTAIL + 1) * NUMSTATES);
|
||||
if (!h->beta) {
|
||||
perror("vec_malloc");
|
||||
return -1;
|
||||
|
@ -167,15 +175,15 @@ int map_gen_init(map_gen_t * h, int max_long_cb)
|
|||
return 0;
|
||||
}
|
||||
|
||||
void map_gen_free(map_gen_t * h)
|
||||
void srslte_map_gen_free(srslte_map_gen_t * h)
|
||||
{
|
||||
if (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 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++)
|
||||
h->beta[(long_cb + TAIL) * NUMSTATES + k] = -INF;
|
||||
|
||||
map_gen_beta(h, input, parity, long_cb);
|
||||
map_gen_alpha(h, input, parity, output, long_cb);
|
||||
srslte_map_gen_beta(h, input, parity, 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
|
||||
*
|
||||
************************************************/
|
||||
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;
|
||||
bzero(h, sizeof(tdec_t));
|
||||
uint32_t len = max_long_cb + TOTALTAIL;
|
||||
bzero(h, sizeof(srslte_tdec_t));
|
||||
uint32_t len = max_long_cb + SRSLTE_TCOD_TOTALTAIL;
|
||||
|
||||
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) {
|
||||
perror("vec_malloc");
|
||||
goto clean_and_exit;
|
||||
}
|
||||
h->llr2 = vec_malloc(sizeof(llr_t) * len);
|
||||
h->llr2 = vec_malloc(sizeof(srslte_llr_t) * len);
|
||||
if (!h->llr2) {
|
||||
perror("vec_malloc");
|
||||
goto clean_and_exit;
|
||||
}
|
||||
h->w = vec_malloc(sizeof(llr_t) * len);
|
||||
h->w = vec_malloc(sizeof(srslte_llr_t) * len);
|
||||
if (!h->w) {
|
||||
perror("vec_malloc");
|
||||
goto clean_and_exit;
|
||||
}
|
||||
h->syst = vec_malloc(sizeof(llr_t) * len);
|
||||
h->syst = vec_malloc(sizeof(srslte_llr_t) * len);
|
||||
if (!h->syst) {
|
||||
perror("vec_malloc");
|
||||
goto clean_and_exit;
|
||||
}
|
||||
h->parity = vec_malloc(sizeof(llr_t) * len);
|
||||
h->parity = vec_malloc(sizeof(srslte_llr_t) * len);
|
||||
if (!h->parity) {
|
||||
perror("vec_malloc");
|
||||
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;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
ret = 0;
|
||||
clean_and_exit:if (ret == -1) {
|
||||
tdec_free(h);
|
||||
srslte_tdec_free(h);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void tdec_free(tdec_t * h)
|
||||
void srslte_tdec_free(srslte_tdec_t * h)
|
||||
{
|
||||
if (h->llr1) {
|
||||
free(h->llr1);
|
||||
|
@ -260,45 +268,45 @@ void tdec_free(tdec_t * h)
|
|||
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;
|
||||
|
||||
// Prepare systematic and parity bits for MAP DEC #1
|
||||
for (i = 0; i < long_cb; i++) {
|
||||
h->syst[i] = input[RATE * i] + h->w[i];
|
||||
h->parity[i] = input[RATE * i + 1];
|
||||
h->syst[i] = input[SRSLTE_TCOD_RATE * i] + h->w[i];
|
||||
h->parity[i] = input[SRSLTE_TCOD_RATE * i + 1];
|
||||
}
|
||||
for (i = long_cb; i < long_cb + RATE; i++) {
|
||||
h->syst[i] = input[RATE * long_cb + NINPUTS * (i - long_cb)];
|
||||
h->parity[i] = input[RATE * long_cb + NINPUTS * (i - long_cb) + 1];
|
||||
for (i = long_cb; i < long_cb + SRSLTE_TCOD_RATE; i++) {
|
||||
h->syst[i] = input[SRSLTE_TCOD_RATE * long_cb + NINPUTS * (i - long_cb)];
|
||||
h->parity[i] = input[SRSLTE_TCOD_RATE * long_cb + NINPUTS * (i - long_cb) + 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
|
||||
for (i = 0; i < long_cb; i++) {
|
||||
h->syst[i] = h->llr1[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] =
|
||||
input[RATE * long_cb + NINPUTS * RATE + NINPUTS * (i - long_cb)];
|
||||
h->parity[i] = input[RATE * long_cb + NINPUTS * RATE
|
||||
input[SRSLTE_TCOD_RATE * long_cb + NINPUTS * SRSLTE_TCOD_RATE + NINPUTS * (i - long_cb)];
|
||||
h->parity[i] = input[SRSLTE_TCOD_RATE * long_cb + NINPUTS * SRSLTE_TCOD_RATE
|
||||
+ NINPUTS * (i - long_cb) + 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
|
||||
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) {
|
||||
fprintf(stderr, "TDEC was initialized for max_long_cb=%d\n",
|
||||
h->max_long_cb);
|
||||
return -1;
|
||||
}
|
||||
memset(h->w, 0, sizeof(llr_t) * long_cb);
|
||||
return tc_interl_LTE_gen(&h->interleaver, long_cb);
|
||||
memset(h->w, 0, sizeof(srslte_llr_t) * 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;
|
||||
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 iter = 0;
|
||||
|
||||
if (tdec_reset(h, long_cb)) {
|
||||
if (srslte_tdec_reset(h, long_cb)) {
|
||||
return SRSLTE_ERROR;
|
||||
}
|
||||
|
||||
do {
|
||||
tdec_iteration(h, input, long_cb);
|
||||
srslte_tdec_iteration(h, input, long_cb);
|
||||
iter++;
|
||||
} while (iter < nof_iterations);
|
||||
|
||||
tdec_decision(h, output, long_cb);
|
||||
srslte_tdec_decision(h, output, long_cb);
|
||||
|
||||
return SRSLTE_SUCCESS;
|
||||
}
|
||||
|
|
|
@ -41,7 +41,7 @@
|
|||
#define DEB 0
|
||||
|
||||
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 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) {
|
||||
viterbi_t *q = o;
|
||||
srslte_viterbi_t *q = o;
|
||||
|
||||
if (frame_length > q->framebits) {
|
||||
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) {
|
||||
viterbi_t *q = o;
|
||||
srslte_viterbi_t *q = o;
|
||||
if (q->symbols_uc) {
|
||||
free(q->symbols_uc);
|
||||
}
|
||||
|
@ -109,14 +109,14 @@ void free37(void *o) {
|
|||
}
|
||||
|
||||
void free39(void *o) {
|
||||
viterbi_t *q = o;
|
||||
srslte_viterbi_t *q = o;
|
||||
if (q->symbols_uc) {
|
||||
free(q->symbols_uc);
|
||||
}
|
||||
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->R = 3;
|
||||
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->R = 3;
|
||||
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;
|
||||
}
|
||||
|
||||
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) {
|
||||
switch (type) {
|
||||
case viterbi_37:
|
||||
case SRSLTE_VITERBI_37:
|
||||
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);
|
||||
default:
|
||||
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) {
|
||||
q->free(q);
|
||||
}
|
||||
bzero(q, sizeof(viterbi_t));
|
||||
bzero(q, sizeof(srslte_viterbi_t));
|
||||
}
|
||||
|
||||
/* 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;
|
||||
if (frame_length > q->framebits) {
|
||||
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) {
|
||||
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];
|
||||
viterbi_type_t type;
|
||||
srslte_viterbi_type_t type;
|
||||
if (h->init.rate == 2) {
|
||||
if (h->init.constraint_length == 7) {
|
||||
type = viterbi_27;
|
||||
type = SRSLTE_VITERBI_27;
|
||||
} else if (h->init.constraint_length == 9) {
|
||||
type = viterbi_29;
|
||||
type = SRSLTE_VITERBI_29;
|
||||
} else {
|
||||
fprintf(stderr, "Unsupported decoder %d/%d\n", h->init.rate,
|
||||
h->init.constraint_length);
|
||||
|
@ -247,9 +247,9 @@ int viterbi_initialize(viterbi_hl* h) {
|
|||
}
|
||||
} else if (h->init.rate == 3) {
|
||||
if (h->init.constraint_length == 7) {
|
||||
type = viterbi_37;
|
||||
type = SRSLTE_VITERBI_37;
|
||||
} else if (h->init.constraint_length == 9) {
|
||||
type = viterbi_39;
|
||||
type = SRSLTE_VITERBI_39;
|
||||
} else {
|
||||
fprintf(stderr, "Unsupported decoder %d/%d\n", h->init.rate,
|
||||
h->init.constraint_length);
|
||||
|
@ -263,20 +263,20 @@ int viterbi_initialize(viterbi_hl* h) {
|
|||
poly[0] = h->init.generator_0;
|
||||
poly[1] = h->init.generator_1;
|
||||
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);
|
||||
}
|
||||
|
||||
int viterbi_work(viterbi_hl* hl) {
|
||||
int srslte_viterbi_work(srslte_viterbi_hl* hl) {
|
||||
if (hl->in_len != hl->init.frame_length) {
|
||||
fprintf(stderr, "Expected input length %d but got %d\n",
|
||||
hl->init.frame_length, hl->in_len);
|
||||
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) {
|
||||
viterbi_free(&h->obj);
|
||||
int srslte_viterbi_stop(srslte_viterbi_hl* h) {
|
||||
srslte_viterbi_free(&h->obj);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -36,15 +36,15 @@
|
|||
#include "srslte/srslte.h"
|
||||
#include "crc_test.h"
|
||||
|
||||
int num_bits = 5001, crc_length = 24;
|
||||
uint32_t crc_poly = 0x1864CFB;
|
||||
int num_bits = 5001, srslte_crc_length = 24;
|
||||
uint32_t srslte_crc_poly = 0x1864CFB;
|
||||
uint32_t seed = 1;
|
||||
|
||||
void usage(char *prog) {
|
||||
printf("Usage: %s [nlps]\n", prog);
|
||||
printf("\t-n num_bits [Default %d]\n", num_bits);
|
||||
printf("\t-l crc_length [Default %d]\n", crc_length);
|
||||
printf("\t-p crc_poly (Hex) [Default 0x%x]\n", crc_poly);
|
||||
printf("\t-l srslte_crc_length [Default %d]\n", srslte_crc_length);
|
||||
printf("\t-p srslte_crc_poly (Hex) [Default 0x%x]\n", srslte_crc_poly);
|
||||
printf("\t-s seed [Default 0=time]\n");
|
||||
}
|
||||
|
||||
|
@ -56,10 +56,10 @@ void parse_args(int argc, char **argv) {
|
|||
num_bits = atoi(argv[optind]);
|
||||
break;
|
||||
case 'l':
|
||||
crc_length = atoi(argv[optind]);
|
||||
srslte_crc_length = atoi(argv[optind]);
|
||||
break;
|
||||
case 'p':
|
||||
crc_poly = (uint32_t) strtoul(argv[optind], NULL, 16);
|
||||
srslte_crc_poly = (uint32_t) strtoul(argv[optind], NULL, 16);
|
||||
break;
|
||||
case 's':
|
||||
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 i;
|
||||
uint8_t *data;
|
||||
uint32_t crc_word, expected_word;
|
||||
crc_t crc_p;
|
||||
uint32_t srslte_crc_word, expected_word;
|
||||
srslte_crc_t srslte_crc_p;
|
||||
|
||||
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) {
|
||||
perror("malloc");
|
||||
exit(-1);
|
||||
|
@ -96,20 +96,20 @@ int main(int argc, char **argv) {
|
|||
}
|
||||
|
||||
//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);
|
||||
}
|
||||
|
||||
// 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);
|
||||
|
||||
// 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)) {
|
||||
fprintf(stderr, "Test parameters not defined in test_results.h\n");
|
||||
exit(-1);
|
||||
}
|
||||
exit(expected_word != crc_word);
|
||||
exit(expected_word != srslte_crc_word);
|
||||
}
|
||||
|
|
|
@ -100,7 +100,7 @@ int main(int argc, char **argv) {
|
|||
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);
|
||||
}
|
||||
|
||||
|
@ -108,7 +108,7 @@ int main(int argc, char **argv) {
|
|||
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);
|
||||
}
|
||||
|
||||
|
|
|
@ -41,7 +41,7 @@
|
|||
void help()
|
||||
{
|
||||
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 */
|
||||
|
@ -81,7 +81,7 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
|
|||
// allocate memory for output bits
|
||||
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);
|
||||
|
||||
if (nlhs >= 1) {
|
||||
|
|
|
@ -124,14 +124,14 @@ int main(int argc, char **argv) {
|
|||
}
|
||||
|
||||
for (i=0;i<nof_filler_bits;i++) {
|
||||
bits[3*i+0] = TX_NULL;
|
||||
bits[3*i+1] = TX_NULL;
|
||||
bits[3*i+0] = SRSLTE_TX_NULL;
|
||||
bits[3*i+1] = SRSLTE_TX_NULL;
|
||||
}
|
||||
|
||||
printf("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: ");
|
||||
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_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);
|
||||
|
||||
printf("UMRM: ");
|
||||
|
|
|
@ -139,8 +139,8 @@ int main(int argc, char **argv) {
|
|||
uint32_t coded_length;
|
||||
struct timeval tdata[3];
|
||||
float mean_usec;
|
||||
tdec_t tdec;
|
||||
tcod_t tcod;
|
||||
srslte_tdec_t tdec;
|
||||
srslte_tcod_t tcod;
|
||||
|
||||
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));
|
||||
}
|
||||
|
||||
coded_length = 3 * (frame_length) + TOTALTAIL;
|
||||
coded_length = 3 * (frame_length) + SRSLTE_TCOD_TOTALTAIL;
|
||||
|
||||
printf(" Frame length: %d\n", frame_length);
|
||||
if (ebno_db < 100.0) {
|
||||
|
@ -190,12 +190,12 @@ int main(int argc, char **argv) {
|
|||
exit(-1);
|
||||
}
|
||||
|
||||
if (tcod_init(&tcod, frame_length)) {
|
||||
if (srslte_tcod_init(&tcod, frame_length)) {
|
||||
fprintf(stderr, "Error initiating Turbo coder\n");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
if (tdec_init(&tdec, frame_length)) {
|
||||
if (srslte_tdec_init(&tdec, frame_length)) {
|
||||
fprintf(stderr, "Error initiating Turbo decoder\n");
|
||||
exit(-1);
|
||||
}
|
||||
|
@ -235,7 +235,7 @@ int main(int argc, char **argv) {
|
|||
symbols[j] = known_data_encoded[j];
|
||||
}
|
||||
} 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++) {
|
||||
|
@ -245,7 +245,7 @@ int main(int argc, char **argv) {
|
|||
srslte_ch_awgn_f(llr, llr, var[i], coded_length);
|
||||
|
||||
/* decoder */
|
||||
tdec_reset(&tdec, frame_length);
|
||||
srslte_tdec_reset(&tdec, frame_length);
|
||||
|
||||
uint32_t t;
|
||||
if (nof_iterations == -1) {
|
||||
|
@ -257,8 +257,8 @@ int main(int argc, char **argv) {
|
|||
|
||||
if (!j)
|
||||
gettimeofday(&tdata[1], NULL); // Only measure 1 iteration
|
||||
tdec_iteration(&tdec, llr, frame_length);
|
||||
tdec_decision(&tdec, data_rx, frame_length);
|
||||
srslte_tdec_iteration(&tdec, llr, frame_length);
|
||||
srslte_tdec_decision(&tdec, data_rx, frame_length);
|
||||
if (!j)
|
||||
gettimeofday(&tdata[2], NULL);
|
||||
if (!j)
|
||||
|
@ -322,8 +322,8 @@ int main(int argc, char **argv) {
|
|||
free(llr_c);
|
||||
free(data_rx);
|
||||
|
||||
tdec_free(&tdec);
|
||||
tcod_free(&tcod);
|
||||
srslte_tdec_free(&tdec);
|
||||
srslte_tcod_free(&tcod);
|
||||
|
||||
printf("\n");
|
||||
output_matlab(ber, snr_points);
|
||||
|
|
|
@ -47,7 +47,7 @@ void help()
|
|||
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
|
||||
{
|
||||
|
||||
tdec_t tdec;
|
||||
srslte_tdec_t tdec;
|
||||
float *input_llr;
|
||||
uint8_t *output_data;
|
||||
uint32_t nof_bits;
|
||||
|
@ -86,18 +86,18 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
|
|||
// allocate memory for output bits
|
||||
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");
|
||||
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) {
|
||||
mexutils_write_uint8(output_data, &plhs[0], nof_bits, 1);
|
||||
}
|
||||
|
||||
tdec_free(&tdec);
|
||||
srslte_tdec_free(&tdec);
|
||||
|
||||
free(input_llr);
|
||||
free(output_data);
|
||||
|
|
|
@ -92,9 +92,9 @@ void parse_args(int argc, char **argv) {
|
|||
}
|
||||
|
||||
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;
|
||||
FILE *f = fopen("viterbi_snr.m", "w");
|
||||
FILE *f = fopen("srslte_viterbi_snr.m", "w");
|
||||
if (!f) {
|
||||
perror("fopen");
|
||||
exit(-1);
|
||||
|
@ -129,9 +129,9 @@ int main(int argc, char **argv) {
|
|||
int snr_points;
|
||||
float ber[NTYPES][SNR_POINTS];
|
||||
uint32_t errors[NTYPES];
|
||||
viterbi_type_t viterbi_type[NCODS];
|
||||
viterbi_t dec[NCODS];
|
||||
convcoder_t cod[NCODS];
|
||||
srslte_viterbi_type_t srslte_viterbi_type[NCODS];
|
||||
srslte_viterbi_t dec[NCODS];
|
||||
srslte_convcoder_t cod[NCODS];
|
||||
int coded_length[NCODS];
|
||||
int n, ncods, max_coded_length;
|
||||
|
||||
|
@ -150,7 +150,7 @@ int main(int argc, char **argv) {
|
|||
cod[0].poly[2] = 0x127;
|
||||
cod[0].tail_biting = false;
|
||||
cod[0].K = 9;
|
||||
viterbi_type[0] = viterbi_39;
|
||||
srslte_viterbi_type[0] = SRSLTE_VITERBI_39;
|
||||
ncods=1;
|
||||
break;
|
||||
case 7:
|
||||
|
@ -159,7 +159,7 @@ int main(int argc, char **argv) {
|
|||
cod[0].poly[2] = 0x57;
|
||||
cod[0].K = 7;
|
||||
cod[0].tail_biting = tail_biting;
|
||||
viterbi_type[0] = viterbi_37;
|
||||
srslte_viterbi_type[0] = SRSLTE_VITERBI_37;
|
||||
ncods=1;
|
||||
break;
|
||||
default:
|
||||
|
@ -168,19 +168,19 @@ int main(int argc, char **argv) {
|
|||
cod[0].poly[2] = 0x127;
|
||||
cod[0].tail_biting = false;
|
||||
cod[0].K = 9;
|
||||
viterbi_type[0] = viterbi_39;
|
||||
srslte_viterbi_type[0] = SRSLTE_VITERBI_39;
|
||||
cod[1].poly[0] = 0x6D;
|
||||
cod[1].poly[1] = 0x4F;
|
||||
cod[1].poly[2] = 0x57;
|
||||
cod[1].tail_biting = false;
|
||||
cod[1].K = 7;
|
||||
viterbi_type[1] = viterbi_37;
|
||||
srslte_viterbi_type[1] = SRSLTE_VITERBI_37;
|
||||
cod[2].poly[0] = 0x6D;
|
||||
cod[2].poly[1] = 0x4F;
|
||||
cod[2].poly[2] = 0x57;
|
||||
cod[2].tail_biting = true;
|
||||
cod[2].K = 7;
|
||||
viterbi_type[2] = viterbi_37;
|
||||
srslte_viterbi_type[2] = SRSLTE_VITERBI_37;
|
||||
ncods=3;
|
||||
}
|
||||
|
||||
|
@ -191,7 +191,7 @@ int main(int argc, char **argv) {
|
|||
if (coded_length[i] > max_coded_length) {
|
||||
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");
|
||||
}
|
||||
|
||||
|
@ -272,7 +272,7 @@ int main(int argc, char **argv) {
|
|||
|
||||
/* coded BER */
|
||||
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++) {
|
||||
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]);
|
||||
|
||||
/* 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 */
|
||||
|
@ -312,7 +312,7 @@ int main(int argc, char **argv) {
|
|||
}
|
||||
}
|
||||
for (n=0;n<ncods;n++) {
|
||||
viterbi_free(&dec[n]);
|
||||
srslte_viterbi_free(&dec[n]);
|
||||
}
|
||||
|
||||
free(data_tx);
|
||||
|
|
|
@ -46,7 +46,7 @@ void help()
|
|||
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
|
||||
{
|
||||
|
||||
viterbi_t viterbi;
|
||||
srslte_viterbi_t viterbi;
|
||||
float *input_llr;
|
||||
uint8_t *output_data;
|
||||
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));
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
if (nrhs >= 2) {
|
||||
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) {
|
||||
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);
|
||||
}
|
||||
|
||||
viterbi_free(&viterbi);
|
||||
srslte_viterbi_free(&viterbi);
|
||||
|
||||
free(input_llr);
|
||||
free(output_data);
|
||||
|
|
|
@ -41,15 +41,15 @@
|
|||
#include "srslte/filter/dft_precoding.h"
|
||||
|
||||
/* 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;
|
||||
bzero(q, sizeof(dft_precoding_t));
|
||||
bzero(q, sizeof(srslte_srslte_dft_precoding_t));
|
||||
|
||||
if (max_prb <= SRSLTE_MAX_PRB) {
|
||||
ret = SRSLTE_ERROR;
|
||||
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);
|
||||
if (dft_plan_c(&q->dft_plan[i], i*SRSLTE_NRE, FORWARD)) {
|
||||
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:
|
||||
if (ret == SRSLTE_ERROR) {
|
||||
dft_precoding_free(q);
|
||||
srslte_srslte_dft_precoding_free(q);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* 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++) {
|
||||
if(dft_precoding_valid_prb(i)) {
|
||||
if(srslte_srslte_dft_precoding_valid_prb(i)) {
|
||||
DEBUG("Freeing DFT precoding plan for %d PRBs\n", i);
|
||||
dft_plan_free(&q->dft_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) {
|
||||
return true;
|
||||
} 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)
|
||||
{
|
||||
|
||||
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);
|
||||
return SRSLTE_ERROR;
|
||||
}
|
||||
|
@ -111,10 +111,10 @@ int dft_precoding(dft_precoding_t *q, cf_t *input, cf_t *output,
|
|||
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)
|
||||
{
|
||||
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);
|
||||
return SRSLTE_ERROR;
|
||||
}
|
||||
|
|
|
@ -43,11 +43,11 @@
|
|||
|
||||
#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) {
|
||||
|
||||
int ret = -1;
|
||||
bzero(q, sizeof(filter2d_t));
|
||||
bzero(q, sizeof(srslte_filter2d_t));
|
||||
|
||||
if (matrix_init((void***)&q->taps, ntime, nfreq, sizeof(float))) {
|
||||
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;
|
||||
|
||||
free_and_exit: if (ret == -1) {
|
||||
filter2d_free(q);
|
||||
srslte_filter2d_free(q);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void filter2d_free(filter2d_t *q) {
|
||||
void srslte_filter2d_free(srslte_filter2d_t *q) {
|
||||
|
||||
matrix_free((void**) q->taps, q->ntime);
|
||||
if (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)
|
||||
{
|
||||
|
||||
|
@ -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);
|
||||
}
|
||||
|
||||
if (filter2d_init(q, taps, ntime, nfreq, sztime, szfreq)) {
|
||||
if (srslte_filter2d_init(q, taps, ntime, nfreq, sztime, szfreq)) {
|
||||
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.
|
||||
* 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;
|
||||
|
||||
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));
|
||||
}
|
||||
|
||||
/** Adds samples x to the from the given time/freq indexes to the filter
|
||||
* 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;
|
||||
|
||||
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;
|
||||
|
||||
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));
|
||||
}
|
||||
|
|
|
@ -37,7 +37,7 @@
|
|||
|
||||
|
||||
/* 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) {
|
||||
free(q->seq_buff);
|
||||
q->seq_buff_nwords = 0;
|
||||
|
@ -60,31 +60,31 @@ static int gen_seq_buff(binsource_t* q, int nwords) {
|
|||
/**
|
||||
* Initializes the binsource object.
|
||||
*/
|
||||
void binsource_init(binsource_t* q) {
|
||||
bzero((void*) q,sizeof(binsource_t));
|
||||
void srslte_binsource_init(srslte_binsource_t* q) {
|
||||
bzero((void*) q,sizeof(srslte_binsource_t));
|
||||
}
|
||||
|
||||
/**
|
||||
* Destroys binsource object
|
||||
*/
|
||||
void binsource_free(binsource_t* q) {
|
||||
void srslte_binsource_free(srslte_binsource_t* q) {
|
||||
if (q->seq_buff) {
|
||||
free(q->seq_buff);
|
||||
}
|
||||
bzero(q, sizeof(binsource_t));
|
||||
bzero(q, sizeof(srslte_binsource_t));
|
||||
}
|
||||
|
||||
/**
|
||||
* 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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets local time as seed.
|
||||
*/
|
||||
void binsource_seed_time(binsource_t *q) {
|
||||
void srslte_binsource_seed_time(srslte_binsource_t *q) {
|
||||
struct timeval t1;
|
||||
gettimeofday(&t1, NULL);
|
||||
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
|
||||
*/
|
||||
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))) {
|
||||
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);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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))) {
|
||||
return -1;
|
||||
|
@ -137,17 +137,17 @@ int binsource_generate(binsource_t* q, uint8_t *bits, int nbits) {
|
|||
|
||||
|
||||
/* 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) {
|
||||
binsource_seed_set(&hl->obj,hl->init.seed);
|
||||
srslte_binsource_seed_set(&hl->obj,hl->init.seed);
|
||||
} else {
|
||||
binsource_seed_time(&hl->obj);
|
||||
srslte_binsource_seed_time(&hl->obj);
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
@ -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;
|
||||
|
||||
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;
|
||||
} 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) {
|
||||
hl->out_len = hl->ctrl_in.nbits;
|
||||
|
@ -173,8 +173,8 @@ int binsource_work(binsource_hl* hl) {
|
|||
return ret;
|
||||
}
|
||||
|
||||
int binsource_stop(binsource_hl* hl) {
|
||||
binsource_free(&hl->obj);
|
||||
int srslte_binsource_stop(srslte_binsource_hl* hl) {
|
||||
srslte_binsource_free(&hl->obj);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -34,8 +34,8 @@
|
|||
|
||||
#include "srslte/io/filesink.h"
|
||||
|
||||
int filesink_init(filesink_t *q, char *filename, data_type_t type) {
|
||||
bzero(q, sizeof(filesink_t));
|
||||
int srslte_filesink_init(srslte_filesink_t *q, char *filename, srslte_datatype_t type) {
|
||||
bzero(q, sizeof(srslte_filesink_t));
|
||||
q->f = fopen(filename, "w");
|
||||
if (!q->f) {
|
||||
perror("fopen");
|
||||
|
@ -45,14 +45,14 @@ int filesink_init(filesink_t *q, char *filename, data_type_t type) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
void filesink_free(filesink_t *q) {
|
||||
void srslte_filesink_free(srslte_filesink_t *q) {
|
||||
if (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;
|
||||
float *fbuf = (float*) buffer;
|
||||
_Complex float *cbuf = (_Complex float*) buffer;
|
||||
|
@ -60,12 +60,12 @@ int filesink_write(filesink_t *q, void *buffer, int nsamples) {
|
|||
int size;
|
||||
|
||||
switch(q->type) {
|
||||
case FLOAT:
|
||||
case SRSLTE_FLOAT:
|
||||
for (i=0;i<nsamples;i++) {
|
||||
fprintf(q->f,"%g\n",fbuf[i]);
|
||||
}
|
||||
break;
|
||||
case COMPLEX_FLOAT:
|
||||
case SRSLTE_COMPLEX_FLOAT:
|
||||
for (i=0;i<nsamples;i++) {
|
||||
if (__imag__ cbuf[i] >= 0)
|
||||
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]));
|
||||
}
|
||||
break;
|
||||
case COMPLEX_SHORT:
|
||||
case SRSLTE_COMPLEX_SHORT:
|
||||
for (i=0;i<nsamples;i++) {
|
||||
if (__imag__ sbuf[i] >= 0)
|
||||
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]));
|
||||
}
|
||||
break;
|
||||
case FLOAT_BIN:
|
||||
case COMPLEX_FLOAT_BIN:
|
||||
case COMPLEX_SHORT_BIN:
|
||||
if (q->type == FLOAT_BIN) {
|
||||
case SRSLTE_FLOAT_BIN:
|
||||
case SRSLTE_COMPLEX_FLOAT_BIN:
|
||||
case SRSLTE_COMPLEX_SHORT_BIN:
|
||||
if (q->type == SRSLTE_FLOAT_BIN) {
|
||||
size = sizeof(float);
|
||||
} else if (q->type == COMPLEX_FLOAT_BIN) {
|
||||
} else if (q->type == SRSLTE_COMPLEX_FLOAT_BIN) {
|
||||
size = sizeof(_Complex float);
|
||||
} else if (q->type == COMPLEX_SHORT_BIN) {
|
||||
} else if (q->type == SRSLTE_COMPLEX_SHORT_BIN) {
|
||||
size = sizeof(_Complex short);
|
||||
}
|
||||
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) {
|
||||
return filesink_init(&h->obj, h->init.file_name, h->init.data_type);
|
||||
int srslte_filesink_initialize(srslte_filesink_hl* h) {
|
||||
return srslte_filesink_init(&h->obj, h->init.file_name, h->init.data_type);
|
||||
}
|
||||
|
||||
int filesink_work(filesink_hl* h) {
|
||||
if (filesink_write(&h->obj, h->input, h->in_len)<0) {
|
||||
int srslte_filesink_work(srslte_filesink_hl* h) {
|
||||
if (srslte_filesink_write(&h->obj, h->input, h->in_len)<0) {
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int filesink_stop(filesink_hl* h) {
|
||||
filesink_free(&h->obj);
|
||||
int srslte_filesink_stop(srslte_filesink_hl* h) {
|
||||
srslte_filesink_free(&h->obj);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -32,8 +32,8 @@
|
|||
|
||||
#include "srslte/io/filesource.h"
|
||||
|
||||
int filesource_init(filesource_t *q, char *filename, data_type_t type) {
|
||||
bzero(q, sizeof(filesource_t));
|
||||
int srslte_filesource_init(srslte_filesource_t *q, char *filename, srslte_datatype_t type) {
|
||||
bzero(q, sizeof(srslte_filesource_t));
|
||||
q->f = fopen(filename, "r");
|
||||
if (!q->f) {
|
||||
perror("fopen");
|
||||
|
@ -43,14 +43,14 @@ int filesource_init(filesource_t *q, char *filename, data_type_t type) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
void filesource_free(filesource_t *q) {
|
||||
void srslte_filesource_free(srslte_filesource_t *q) {
|
||||
if (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);
|
||||
}
|
||||
|
||||
|
@ -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;
|
||||
float *fbuf = (float*) buffer;
|
||||
_Complex float *cbuf = (_Complex float*) buffer;
|
||||
|
@ -79,33 +79,33 @@ int filesource_read(filesource_t *q, void *buffer, int nsamples) {
|
|||
int size;
|
||||
|
||||
switch(q->type) {
|
||||
case FLOAT:
|
||||
case SRSLTE_FLOAT:
|
||||
for (i=0;i<nsamples;i++) {
|
||||
if (EOF == fscanf(q->f,"%g\n",&fbuf[i]))
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case COMPLEX_FLOAT:
|
||||
case SRSLTE_COMPLEX_FLOAT:
|
||||
for (i=0;i<nsamples;i++) {
|
||||
if (read_complex_f(q->f, &cbuf[i])) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case COMPLEX_SHORT:
|
||||
case SRSLTE_COMPLEX_SHORT:
|
||||
for (i=0;i<nsamples;i++) {
|
||||
if (EOF == fscanf(q->f,"%hd%hdi\n",&(__real__ sbuf[i]),&(__imag__ sbuf[i])))
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case FLOAT_BIN:
|
||||
case COMPLEX_FLOAT_BIN:
|
||||
case COMPLEX_SHORT_BIN:
|
||||
if (q->type == FLOAT_BIN) {
|
||||
case SRSLTE_FLOAT_BIN:
|
||||
case SRSLTE_COMPLEX_FLOAT_BIN:
|
||||
case SRSLTE_COMPLEX_SHORT_BIN:
|
||||
if (q->type == SRSLTE_FLOAT_BIN) {
|
||||
size = sizeof(float);
|
||||
} else if (q->type == COMPLEX_FLOAT_BIN) {
|
||||
} else if (q->type == SRSLTE_COMPLEX_FLOAT_BIN) {
|
||||
size = sizeof(_Complex float);
|
||||
} else if (q->type == COMPLEX_SHORT_BIN) {
|
||||
} else if (q->type == SRSLTE_COMPLEX_SHORT_BIN) {
|
||||
size = sizeof(_Complex short);
|
||||
}
|
||||
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) {
|
||||
return filesource_init(&h->obj, h->init.file_name, h->init.data_type);
|
||||
int srslte_filesource_initialize(srslte_filesource_hl* h) {
|
||||
return srslte_filesource_init(&h->obj, h->init.file_name, h->init.data_type);
|
||||
}
|
||||
|
||||
int filesource_work(filesource_hl* h) {
|
||||
h->out_len = filesource_read(&h->obj, h->output, h->ctrl_in.nsamples);
|
||||
int srslte_filesource_work(srslte_filesource_hl* h) {
|
||||
h->out_len = srslte_filesource_read(&h->obj, h->output, h->ctrl_in.nsamples);
|
||||
if (h->out_len < 0) {
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int filesource_stop(filesource_hl* h) {
|
||||
filesource_free(&h->obj);
|
||||
int srslte_filesource_stop(srslte_filesource_hl* h) {
|
||||
srslte_filesource_free(&h->obj);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -39,10 +39,10 @@
|
|||
|
||||
#include "srslte/io/netsink.h"
|
||||
|
||||
int netsink_init(netsink_t *q, char *address, int port, netsink_type_t type) {
|
||||
bzero(q, sizeof(netsink_t));
|
||||
int srslte_netsink_init(srslte_netsink_t *q, char *address, int port, srslte_netsink_type_t type) {
|
||||
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) {
|
||||
perror("socket");
|
||||
return -1;
|
||||
|
@ -57,14 +57,14 @@ int netsink_init(netsink_t *q, char *address, int port, netsink_type_t type) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
void netsink_free(netsink_t *q) {
|
||||
void srslte_netsink_free(srslte_netsink_t *q) {
|
||||
if (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)) {
|
||||
perror("fcntl");
|
||||
return -1;
|
||||
|
@ -72,7 +72,7 @@ int netsink_set_nonblocking(netsink_t *q) {
|
|||
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 (connect(q->sockfd,&q->servaddr,sizeof(q->servaddr)) < 0) {
|
||||
if (errno == ECONNREFUSED || errno == EINPROGRESS) {
|
||||
|
@ -92,7 +92,7 @@ int netsink_write(netsink_t *q, void *buffer, int nof_bytes) {
|
|||
if (n < 0) {
|
||||
if (errno == ECONNRESET) {
|
||||
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) {
|
||||
perror("socket");
|
||||
return -1;
|
||||
|
@ -107,18 +107,18 @@ int netsink_write(netsink_t *q, void *buffer, int nof_bytes) {
|
|||
|
||||
|
||||
|
||||
int netsink_initialize(netsink_hl* h) {
|
||||
return netsink_init(&h->obj, h->init.address, h->init.port, NETSINK_UDP);
|
||||
int srslte_netsink_initialize(srslte_netsink_hl* h) {
|
||||
return srslte_netsink_init(&h->obj, h->init.address, h->init.port, SRSLTE_NETSINK_UDP);
|
||||
}
|
||||
|
||||
int netsink_work(netsink_hl* h) {
|
||||
if (netsink_write(&h->obj, h->input, h->in_len)<0) {
|
||||
int srslte_netsink_work(srslte_netsink_hl* h) {
|
||||
if (srslte_netsink_write(&h->obj, h->input, h->in_len)<0) {
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int netsink_stop(netsink_hl* h) {
|
||||
netsink_free(&h->obj);
|
||||
int srslte_netsink_stop(srslte_netsink_hl* h) {
|
||||
srslte_netsink_free(&h->obj);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -37,10 +37,10 @@
|
|||
|
||||
#include "srslte/io/netsource.h"
|
||||
|
||||
int netsource_init(netsource_t *q, char *address, int port, netsource_type_t type) {
|
||||
bzero(q, sizeof(netsource_t));
|
||||
int srslte_netsource_init(srslte_netsource_t *q, char *address, int port, srslte_netsource_type_t type) {
|
||||
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) {
|
||||
perror("socket");
|
||||
|
@ -61,15 +61,15 @@ int netsource_init(netsource_t *q, char *address, int port, netsource_type_t typ
|
|||
return 0;
|
||||
}
|
||||
|
||||
void netsource_free(netsource_t *q) {
|
||||
void srslte_netsource_free(srslte_netsource_t *q) {
|
||||
if (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) {
|
||||
if (q->type == NETSOURCE_UDP) {
|
||||
int srslte_netsource_read(srslte_netsource_t *q, void *buffer, int nbytes) {
|
||||
if (q->type == SRSLTE_NETSOURCE_UDP) {
|
||||
int n = recv(q->sockfd, buffer, nbytes, 0);
|
||||
|
||||
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)) {
|
||||
perror("fcntl");
|
||||
return -1;
|
||||
|
@ -114,7 +114,7 @@ int netsource_set_nonblocking(netsource_t *q) {
|
|||
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;
|
||||
t.tv_sec = 0;
|
||||
t.tv_usec = microseconds;
|
||||
|
@ -125,19 +125,19 @@ int netsource_set_timeout(netsource_t *q, uint32_t microseconds) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
int netsource_initialize(netsource_hl* h) {
|
||||
return netsource_init(&h->obj, h->init.address, h->init.port, NETSOURCE_UDP);
|
||||
int srslte_netsource_initialize(srslte_netsource_hl* h) {
|
||||
return srslte_netsource_init(&h->obj, h->init.address, h->init.port, SRSLTE_NETSOURCE_UDP);
|
||||
}
|
||||
|
||||
int netsource_work(netsource_hl* h) {
|
||||
h->out_len = netsource_read(&h->obj, h->output, h->ctrl_in.nsamples);
|
||||
int srslte_netsource_work(srslte_netsource_hl* h) {
|
||||
h->out_len = srslte_netsource_read(&h->obj, h->output, h->ctrl_in.nsamples);
|
||||
if (h->out_len < 0) {
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int netsource_stop(netsource_hl* h) {
|
||||
netsource_free(&h->obj);
|
||||
int srslte_netsource_stop(srslte_netsource_hl* h) {
|
||||
srslte_netsource_free(&h->obj);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
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;
|
||||
for (i=0;i<nof_symbols/nof_layers;i++) {
|
||||
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;
|
||||
}
|
||||
|
||||
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]) {
|
||||
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 {
|
||||
int n[2];
|
||||
n[0] = nof_layers / nof_cw;
|
||||
n[1] = nof_layers - n[0];
|
||||
if (nof_symbols[0] / n[0] == nof_symbols[1] / n[1]) {
|
||||
|
||||
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[0], x, n[0], nof_symbols[0]);
|
||||
srslte_layermap_diversity(d[1], &x[n[0]], n[1], nof_symbols[1]);
|
||||
return nof_symbols[0] / n[0];
|
||||
|
||||
} 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
|
||||
* 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) {
|
||||
|
||||
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) {
|
||||
case SINGLE_ANTENNA:
|
||||
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 {
|
||||
fprintf(stderr, "Number of codewords and layers must be 1 for transmission on single antenna ports\n");
|
||||
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:
|
||||
if (nof_cw == 1) {
|
||||
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 {
|
||||
fprintf(stderr, "Number of layers must be 2 or 4 for transmit diversity\n");
|
||||
return -1;
|
||||
|
@ -116,7 +116,7 @@ int layermap_type(cf_t *d[SRSLTE_MAX_CODEWORDS], cf_t *x[SRSLTE_MAX_LAYERS], int
|
|||
}
|
||||
break;
|
||||
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;
|
||||
}
|
||||
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);
|
||||
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;
|
||||
for (i=0;i<nof_layer_symbols;i++) {
|
||||
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;
|
||||
}
|
||||
|
||||
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]) {
|
||||
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 {
|
||||
int n[2];
|
||||
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[1] = n[1] * nof_layer_symbols;
|
||||
|
||||
nof_symbols[0] = 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[0] = srslte_layerdemap_diversity(x, d[0], n[0], nof_layer_symbols);
|
||||
nof_symbols[1] = srslte_layerdemap_diversity(&x[n[0]], d[1], n[1], nof_layer_symbols);
|
||||
}
|
||||
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
|
||||
* 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) {
|
||||
|
||||
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) {
|
||||
case SINGLE_ANTENNA:
|
||||
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;
|
||||
} else {
|
||||
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:
|
||||
if (nof_cw == 1) {
|
||||
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;
|
||||
} else {
|
||||
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;
|
||||
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;
|
||||
}
|
||||
return 0;
|
||||
|
|
|
@ -124,13 +124,13 @@ int main(int argc, char **argv) {
|
|||
}
|
||||
|
||||
/* 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");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
/* 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");
|
||||
exit(-1);
|
||||
}
|
||||
|
|
|
@ -70,11 +70,11 @@ int dci_msg_to_ra_dl(dci_msg_t *msg, uint16_t msg_rnti,
|
|||
if (type.type == PDSCH_SCHED) {
|
||||
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) {
|
||||
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");
|
||||
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
|
||||
*/
|
||||
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 */
|
||||
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 {
|
||||
uint32_t n_vrb_dl;
|
||||
if (crc_is_crnti && nof_prb > 50) {
|
||||
if (srslte_crc_is_crnti && nof_prb > 50) {
|
||||
n_vrb_dl = 16;
|
||||
} else {
|
||||
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;
|
||||
}
|
||||
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;
|
||||
*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);
|
||||
|
||||
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;
|
||||
} else {
|
||||
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
|
||||
bit_pack(data->rv_idx, &y, 2);
|
||||
|
||||
if (crc_is_crnti) {
|
||||
if (srslte_crc_is_crnti) {
|
||||
// TPC not implemented
|
||||
*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,
|
||||
bool crc_is_crnti) {
|
||||
bool srslte_crc_is_crnti) {
|
||||
|
||||
/* pack bits */
|
||||
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 */
|
||||
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;
|
||||
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);
|
||||
|
||||
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++;
|
||||
} else {
|
||||
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
|
||||
bit_pack(data->rv_idx, &y, 2);
|
||||
|
||||
if (crc_is_crnti) {
|
||||
if (srslte_crc_is_crnti) {
|
||||
// TPC not implemented
|
||||
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;
|
||||
if (crc_is_crnti) {
|
||||
if (srslte_crc_is_crnti) {
|
||||
n_prb = ra_nprb_dl(data, nof_prb);
|
||||
} else {
|
||||
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,
|
||||
uint32_t nof_prb, bool crc_is_crnti) {
|
||||
uint32_t nof_prb, bool srslte_crc_is_crnti) {
|
||||
switch (format) {
|
||||
case Format1:
|
||||
return dci_format1_pack(data, msg, nof_prb);
|
||||
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:
|
||||
return dci_format1Cs_pack(data, msg, nof_prb);
|
||||
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,
|
||||
bool crc_is_crnti) {
|
||||
bool srslte_crc_is_crnti) {
|
||||
if (msg->nof_bits == dci_format_sizeof(Format1, nof_prb)) {
|
||||
return dci_format1_unpack(msg, data, 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)) {
|
||||
return dci_format1Cs_unpack(msg, data, nof_prb);
|
||||
} else {
|
||||
|
|
|
@ -41,7 +41,7 @@
|
|||
#include "srslte/utils/vector.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 },
|
||||
{ 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 },
|
||||
|
@ -151,15 +151,15 @@ int pbch_init(pbch_t *q, srslte_cell_t cell) {
|
|||
demod_soft_table_set(&q->demod, &q->mod);
|
||||
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;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
if (crc_init(&q->crc, SRSLTE_LTE_CRC16, 16)) {
|
||||
if (srslte_crc_init(&q->crc, SRSLTE_LTE_CRC16, 16)) {
|
||||
goto clean;
|
||||
}
|
||||
q->encoder.K = 7;
|
||||
|
@ -233,9 +233,9 @@ void pbch_free(pbch_t *q) {
|
|||
free(q->pbch_rm_b);
|
||||
}
|
||||
precoding_free(&q->precoding);
|
||||
sequence_free(&q->seq_pbch);
|
||||
srslte_sequence_free(&q->seq_pbch);
|
||||
modem_table_free(&q->mod);
|
||||
viterbi_free(&q->decoder);
|
||||
srslte_viterbi_free(&q->decoder);
|
||||
demod_soft_free(&q->demod);
|
||||
|
||||
bzero(q, sizeof(pbch_t));
|
||||
|
@ -356,10 +356,10 @@ void pbch_decode_reset(pbch_t *q) {
|
|||
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;
|
||||
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
|
||||
*/
|
||||
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];
|
||||
memcpy(data, bits, BCH_PAYLOADCRC_LEN * sizeof(uint8_t));
|
||||
crc_set_mask(data, nof_ports);
|
||||
int ret = crc_checksum(&q->crc, data, BCH_PAYLOADCRC_LEN);
|
||||
srslte_crc_set_mask(data, nof_ports);
|
||||
int ret = srslte_crc_checksum(&q->crc, data, BCH_PAYLOADCRC_LEN);
|
||||
if (ret == 0) {
|
||||
uint32_t chkzeros=0;
|
||||
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);
|
||||
|
||||
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++) {
|
||||
q->temp[j] = RX_NULL;
|
||||
q->temp[j] = SRSLTE_RX_NULL;
|
||||
}
|
||||
|
||||
/* 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 */
|
||||
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;
|
||||
} else {
|
||||
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 {
|
||||
predecoding_diversity(&q->precoding, q->pbch_symbols[0], q->ce, x, nant,
|
||||
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 */
|
||||
|
@ -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);
|
||||
|
||||
/* encode & modulate */
|
||||
crc_attach(&q->crc, q->data, BCH_PAYLOAD_LEN);
|
||||
crc_set_mask(q->data, q->cell.nof_ports);
|
||||
srslte_crc_attach(&q->crc, q->data, BCH_PAYLOAD_LEN);
|
||||
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 */
|
||||
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,
|
||||
q->nof_symbols / q->cell.nof_ports);
|
||||
} else {
|
||||
|
|
|
@ -88,7 +88,7 @@ int pcfich_init(pcfich_t *q, regs_t *regs, srslte_cell_t cell) {
|
|||
demod_soft_alg_set(&q->demod, APPROX);
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
@ -112,7 +112,7 @@ int pcfich_init(pcfich_t *q, regs_t *regs, srslte_cell_t cell) {
|
|||
|
||||
void pcfich_free(pcfich_t *q) {
|
||||
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);
|
||||
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 {
|
||||
predecoding_diversity(&q->precoding, q->pcfich_symbols[0], ce_precoding, x,
|
||||
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);
|
||||
}
|
||||
|
||||
|
@ -260,7 +260,7 @@ int pcfich_encode(pcfich_t *q, uint32_t cfi, cf_t *slot_symbols[SRSLTE_MAX_PORTS
|
|||
|
||||
/* layer mapping & precoding */
|
||||
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,
|
||||
q->nof_symbols / q->cell.nof_ports);
|
||||
} else {
|
||||
|
|
|
@ -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)) {
|
||||
goto clean;
|
||||
}
|
||||
if (crc_init(&q->crc, SRSLTE_LTE_CRC16, 16)) {
|
||||
if (srslte_crc_init(&q->crc, SRSLTE_LTE_CRC16, 16)) {
|
||||
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++) {
|
||||
// we need to pregenerate the sequence for the maximum number of bits, which is 8 times
|
||||
// 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;
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
|
@ -168,14 +168,14 @@ void pdcch_free(pdcch_t *q) {
|
|||
}
|
||||
|
||||
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);
|
||||
|
||||
precoding_free(&q->precoding);
|
||||
modem_table_free(&q->mod);
|
||||
viterbi_free(&q->decoder);
|
||||
srslte_viterbi_free(&q->decoder);
|
||||
|
||||
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) {
|
||||
|
||||
uint16_t p_bits, crc_res;
|
||||
uint16_t p_bits, srslte_crc_res;
|
||||
uint8_t *x;
|
||||
|
||||
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 */
|
||||
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);
|
||||
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_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()) {
|
||||
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];
|
||||
p_bits = (uint16_t) bit_unpack(&x, 16);
|
||||
crc_res = ((uint16_t) 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,
|
||||
p_bits ^ crc_res);
|
||||
srslte_crc_res = ((uint16_t) srslte_crc_checksum(&q->crc, data, nof_bits) & 0xffff);
|
||||
INFO("p_bits: 0x%x, srslte_crc_checksum: 0x%x, srslte_crc_rem: 0x%x\n", p_bits, srslte_crc_res,
|
||||
p_bits ^ srslte_crc_res);
|
||||
|
||||
if (crc) {
|
||||
*crc = p_bits ^ crc_res;
|
||||
*crc = p_bits ^ srslte_crc_res;
|
||||
}
|
||||
return SRSLTE_SUCCESS;
|
||||
} 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
|
||||
* 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;
|
||||
if (q != NULL &&
|
||||
msg != NULL &&
|
||||
dci_location_isvalid(location) &&
|
||||
crc_rem != NULL)
|
||||
srslte_crc_rem != NULL)
|
||||
{
|
||||
if (location->ncce * 72 + PDCCH_FORMAT_NOF_BITS(location->L) >
|
||||
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);
|
||||
|
||||
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) {
|
||||
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);
|
||||
} else {
|
||||
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);
|
||||
|
@ -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;
|
||||
uint8_t mask[16];
|
||||
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,
|
||||
uint16_t rnti) {
|
||||
convcoder_t encoder;
|
||||
srslte_convcoder_t encoder;
|
||||
uint8_t tmp[3 * (DCI_MAX_BITS + 16)];
|
||||
|
||||
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;
|
||||
memcpy(encoder.poly, poly, 3 * sizeof(int));
|
||||
|
||||
crc_attach(&q->crc, data, nof_bits);
|
||||
crc_set_mask_rnti(&data[nof_bits], rnti);
|
||||
srslte_crc_attach(&q->crc, data, nof_bits);
|
||||
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);
|
||||
if (VERBOSE_ISDEBUG()) {
|
||||
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;
|
||||
} 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 */
|
||||
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);
|
||||
} else {
|
||||
memcpy(q->pdcch_symbols[0], q->pdcch_d, nof_symbols * sizeof(cf_t));
|
||||
|
|
|
@ -288,7 +288,7 @@ void pdsch_free(pdsch_t *q) {
|
|||
}
|
||||
|
||||
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++) {
|
||||
|
@ -309,7 +309,7 @@ void pdsch_free(pdsch_t *q) {
|
|||
int pdsch_set_rnti(pdsch_t *q, uint16_t rnti) {
|
||||
uint32_t 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))) {
|
||||
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 {
|
||||
predecoding_diversity(&q->precoding, q->pdsch_symbols[0], q->ce, x, q->cell.nof_ports,
|
||||
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);
|
||||
}
|
||||
|
||||
|
@ -399,12 +399,12 @@ int pdsch_decode_rnti(pdsch_t *q, harq_t *harq, cf_t *sf_symbols, cf_t *ce[SRSLT
|
|||
|
||||
/* descramble */
|
||||
if (rnti != q->rnti) {
|
||||
sequence_t seq;
|
||||
if (sequence_pdsch(&seq, rnti, 0, 2 * harq->sf_idx, q->cell.id, harq->nof_bits)) {
|
||||
srslte_sequence_t seq;
|
||||
if (srslte_sequence_pdsch(&seq, rnti, 0, 2 * harq->sf_idx, q->cell.id, harq->nof_bits)) {
|
||||
return SRSLTE_ERROR;
|
||||
}
|
||||
scrambling_f_offset(&seq, q->pdsch_e, 0, harq->nof_bits);
|
||||
sequence_free(&seq);
|
||||
srslte_sequence_free(&seq);
|
||||
} else {
|
||||
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) {
|
||||
sequence_t seq;
|
||||
if (sequence_pdsch(&seq, rnti, 0, 2 * harq->sf_idx, q->cell.id, harq->nof_bits)) {
|
||||
srslte_sequence_t seq;
|
||||
if (srslte_sequence_pdsch(&seq, rnti, 0, 2 * harq->sf_idx, q->cell.id, harq->nof_bits)) {
|
||||
return SRSLTE_ERROR;
|
||||
}
|
||||
scrambling_b_offset(&seq, (uint8_t*) q->pdsch_e, 0, harq->nof_bits);
|
||||
sequence_free(&seq);
|
||||
srslte_sequence_free(&seq);
|
||||
} else {
|
||||
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 */
|
||||
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,
|
||||
harq->nof_re / q->cell.nof_ports);
|
||||
} else {
|
||||
|
|
|
@ -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);
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
@ -102,7 +102,7 @@ int phich_init(phich_t *q, regs_t *regs, srslte_cell_t cell) {
|
|||
|
||||
void phich_free(phich_t *q) {
|
||||
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);
|
||||
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 {
|
||||
predecoding_diversity(&q->precoding, q->phich_symbols[0], ce_precoding, x,
|
||||
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);
|
||||
}
|
||||
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 */
|
||||
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,
|
||||
PHICH_SRSLTE_MAX_NSYMB / q->cell.nof_ports);
|
||||
/**FIXME: According to 6.9.2, Precoding for 4 tx ports is different! */
|
||||
|
|
|
@ -52,10 +52,10 @@ bool pucch_cfg_isvalid(pucch_cfg_t *cfg) {
|
|||
/* 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])
|
||||
{
|
||||
sequence_t seq;
|
||||
bzero(&seq, sizeof(sequence_t));
|
||||
srslte_sequence_t seq;
|
||||
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 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;
|
||||
}
|
||||
|
||||
|
|
|
@ -186,7 +186,7 @@ int pusch_init(pusch_t *q, srslte_cell_t cell) {
|
|||
}
|
||||
|
||||
/* 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");
|
||||
goto clean;
|
||||
}
|
||||
|
@ -196,7 +196,7 @@ int pusch_init(pusch_t *q, srslte_cell_t cell) {
|
|||
|
||||
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");
|
||||
goto clean;
|
||||
}
|
||||
|
@ -262,12 +262,12 @@ void pusch_free(pusch_t *q) {
|
|||
free(q->pusch_z);
|
||||
}
|
||||
|
||||
dft_precoding_free(&q->dft_precoding);
|
||||
srslte_srslte_dft_precoding_free(&q->srslte_dft_precoding);
|
||||
|
||||
precoding_free(&q->equalizer);
|
||||
|
||||
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++) {
|
||||
|
@ -292,7 +292,7 @@ int pusch_set_rnti(pusch_t *q, uint16_t rnti) {
|
|||
uint32_t 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))) {
|
||||
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,
|
||||
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);
|
||||
|
||||
/* 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) {
|
||||
sequence_t seq;
|
||||
if (sequence_pusch(&seq, rnti, 2 * harq->sf_idx, q->cell.id, harq->nof_bits)) {
|
||||
srslte_sequence_t seq;
|
||||
if (srslte_sequence_pusch(&seq, rnti, 2 * harq->sf_idx, q->cell.id, harq->nof_bits)) {
|
||||
return SRSLTE_ERROR;
|
||||
}
|
||||
scrambling_b_offset_pusch(&seq, (uint8_t*) q->pusch_q, 0, harq->nof_bits);
|
||||
sequence_free(&seq);
|
||||
srslte_sequence_free(&seq);
|
||||
} else {
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
/* mapping to resource elements */
|
||||
|
|
|
@ -48,20 +48,20 @@ int sch_init(sch_t *q) {
|
|||
if (q) {
|
||||
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");
|
||||
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");
|
||||
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");
|
||||
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");
|
||||
goto clean;
|
||||
}
|
||||
|
@ -96,8 +96,8 @@ void sch_free(sch_t *q) {
|
|||
if (q->cb_out) {
|
||||
free(q->cb_out);
|
||||
}
|
||||
tdec_free(&q->decoder);
|
||||
tcod_free(&q->encoder);
|
||||
srslte_tdec_free(&q->decoder);
|
||||
srslte_tcod_free(&q->encoder);
|
||||
uci_cqi_free(&q->uci_cqi);
|
||||
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) {
|
||||
/* 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 */
|
||||
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 */
|
||||
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> */
|
||||
for (int j = 0; j < F; j++) {
|
||||
q->cb_in[j] = TX_NULL;
|
||||
q->cb_in[j] = SRSLTE_TX_NULL;
|
||||
}
|
||||
if (VERBOSE_ISDEBUG()) {
|
||||
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 */
|
||||
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 */
|
||||
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,
|
||||
&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);
|
||||
|
||||
/* 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,
|
||||
(float*) q->cb_out, 3 * cb_len + 12, harq->rv, F)) {
|
||||
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;
|
||||
uint32_t len_crc;
|
||||
uint8_t *cb_in_ptr;
|
||||
crc_t *crc_ptr;
|
||||
srslte_crc_t *srslte_crc_ptr;
|
||||
early_stop = false;
|
||||
|
||||
tdec_reset(&q->decoder, cb_len);
|
||||
srslte_tdec_reset(&q->decoder, cb_len);
|
||||
|
||||
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++;
|
||||
|
||||
if (harq->cb_segm.C > 1) {
|
||||
len_crc = cb_len;
|
||||
cb_in_ptr = q->cb_in;
|
||||
crc_ptr = &q->crc_cb;
|
||||
srslte_crc_ptr = &q->srslte_crc_cb;
|
||||
} else {
|
||||
len_crc = harq->mcs.tbs+24;
|
||||
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 */
|
||||
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;
|
||||
}
|
||||
|
||||
|
@ -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);
|
||||
|
||||
// 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
|
||||
par_tx = bit_unpack(&p_parity, 24);
|
||||
|
|
|
@ -33,48 +33,48 @@
|
|||
/**
|
||||
* 36.211 6.6.1
|
||||
*/
|
||||
int sequence_pbch(sequence_t *seq, srslte_cp_t cp, uint32_t cell_id) {
|
||||
bzero(seq, sizeof(sequence_t));
|
||||
return sequence_LTE_pr(seq, SRSLTE_CP_ISNORM(cp)?1920:1728, cell_id);
|
||||
int srslte_sequence_pbch(srslte_sequence_t *seq, srslte_cp_t cp, uint32_t cell_id) {
|
||||
bzero(seq, sizeof(srslte_sequence_t));
|
||||
return srslte_sequence_LTE_pr(seq, SRSLTE_CP_ISNORM(cp)?1920:1728, cell_id);
|
||||
}
|
||||
|
||||
/**
|
||||
* 36.211 6.7.1
|
||||
*/
|
||||
int sequence_pcfich(sequence_t *seq, uint32_t nslot, uint32_t cell_id) {
|
||||
bzero(seq, sizeof(sequence_t));
|
||||
return sequence_LTE_pr(seq, 32, (nslot/2+1) * (2*cell_id + 1) * 512 + cell_id);
|
||||
int srslte_sequence_pcfich(srslte_sequence_t *seq, uint32_t nslot, uint32_t cell_id) {
|
||||
bzero(seq, sizeof(srslte_sequence_t));
|
||||
return srslte_sequence_LTE_pr(seq, 32, (nslot/2+1) * (2*cell_id + 1) * 512 + cell_id);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* 36.211 6.9.1
|
||||
*/
|
||||
int sequence_phich(sequence_t *seq, uint32_t nslot, uint32_t cell_id) {
|
||||
bzero(seq, sizeof(sequence_t));
|
||||
return sequence_LTE_pr(seq, 12, (nslot/2+1) * (2*cell_id + 1) * 512 + cell_id);
|
||||
int srslte_sequence_phich(srslte_sequence_t *seq, uint32_t nslot, uint32_t cell_id) {
|
||||
bzero(seq, sizeof(srslte_sequence_t));
|
||||
return srslte_sequence_LTE_pr(seq, 12, (nslot/2+1) * (2*cell_id + 1) * 512 + cell_id);
|
||||
}
|
||||
|
||||
/**
|
||||
* 36.211 6.8.2
|
||||
*/
|
||||
int sequence_pdcch(sequence_t *seq, uint32_t nslot, uint32_t cell_id, uint32_t len) {
|
||||
bzero(seq, sizeof(sequence_t));
|
||||
return sequence_LTE_pr(seq, len, (nslot/2) * 512 + cell_id);
|
||||
int srslte_sequence_pdcch(srslte_sequence_t *seq, uint32_t nslot, uint32_t cell_id, uint32_t len) {
|
||||
bzero(seq, sizeof(srslte_sequence_t));
|
||||
return srslte_sequence_LTE_pr(seq, len, (nslot/2) * 512 + cell_id);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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) {
|
||||
bzero(seq, sizeof(sequence_t));
|
||||
return sequence_LTE_pr(seq, len, (rnti<<14) + (q<<13) + ((nslot/2)<<9) + cell_id);
|
||||
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(srslte_sequence_t));
|
||||
return srslte_sequence_LTE_pr(seq, len, (rnti<<14) + (q<<13) + ((nslot/2)<<9) + cell_id);
|
||||
}
|
||||
|
||||
/**
|
||||
* 36.211 5.3.1
|
||||
*/
|
||||
int sequence_pusch(sequence_t *seq, unsigned short rnti, uint32_t nslot, uint32_t cell_id, uint32_t len) {
|
||||
bzero(seq, sizeof(sequence_t));
|
||||
return sequence_LTE_pr(seq, len, (rnti<<14) + ((nslot/2)<<9) + cell_id);
|
||||
int srslte_sequence_pusch(srslte_sequence_t *seq, unsigned short rnti, uint32_t nslot, uint32_t cell_id, uint32_t len) {
|
||||
bzero(seq, sizeof(srslte_sequence_t));
|
||||
return srslte_sequence_LTE_pr(seq, len, (rnti<<14) + ((nslot/2)<<9) + cell_id);
|
||||
}
|
||||
|
|
|
@ -104,7 +104,7 @@ static uint8_t M_basis_seq_pucch[20][13]={
|
|||
};
|
||||
|
||||
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_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)
|
||||
{
|
||||
convcoder_t encoder;
|
||||
srslte_convcoder_t encoder;
|
||||
|
||||
if (nof_bits + 8 < MAX_CQI_LEN_PUSCH &&
|
||||
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(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);
|
||||
|
||||
|
@ -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));
|
||||
}
|
||||
|
||||
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;
|
||||
} else {
|
||||
|
|
|
@ -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)))
|
||||
|
||||
filesource_t fsrc;
|
||||
srslte_filesource_t fsrc;
|
||||
cf_t *input_buffer, *fft_buffer, *ce[SRSLTE_MAX_PORTS];
|
||||
pbch_t pbch;
|
||||
srslte_fft_t fft;
|
||||
|
@ -102,7 +102,7 @@ void parse_args(int argc, char **argv) {
|
|||
int base_init() {
|
||||
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);
|
||||
exit(-1);
|
||||
}
|
||||
|
@ -154,12 +154,12 @@ int base_init() {
|
|||
void base_free() {
|
||||
int i;
|
||||
|
||||
filesource_free(&fsrc);
|
||||
srslte_filesource_free(&fsrc);
|
||||
|
||||
free(input_buffer);
|
||||
free(fft_buffer);
|
||||
|
||||
filesource_free(&fsrc);
|
||||
srslte_filesource_free(&fsrc);
|
||||
for (i=0;i<cell.nof_ports;i++) {
|
||||
free(ce[i]);
|
||||
}
|
||||
|
@ -191,7 +191,7 @@ int main(int argc, char **argv) {
|
|||
int nof_decoded_mibs = 0;
|
||||
int nread = 0;
|
||||
do {
|
||||
nread = filesource_read(&fsrc, input_buffer, FLEN);
|
||||
nread = srslte_filesource_read(&fsrc, input_buffer, FLEN);
|
||||
|
||||
if (nread > 0) {
|
||||
// process 1st subframe only
|
||||
|
|
|
@ -50,7 +50,7 @@ int flen;
|
|||
|
||||
FILE *fmatlab = NULL;
|
||||
|
||||
filesource_t fsrc;
|
||||
srslte_filesource_t fsrc;
|
||||
cf_t *input_buffer, *fft_buffer, *ce[SRSLTE_MAX_PORTS];
|
||||
pcfich_t pcfich;
|
||||
regs_t regs;
|
||||
|
@ -106,7 +106,7 @@ void parse_args(int argc, char **argv) {
|
|||
int base_init() {
|
||||
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);
|
||||
exit(-1);
|
||||
}
|
||||
|
@ -170,7 +170,7 @@ int base_init() {
|
|||
void base_free() {
|
||||
int i;
|
||||
|
||||
filesource_free(&fsrc);
|
||||
srslte_filesource_free(&fsrc);
|
||||
if (fmatlab) {
|
||||
fclose(fmatlab);
|
||||
}
|
||||
|
@ -178,7 +178,7 @@ void base_free() {
|
|||
free(input_buffer);
|
||||
free(fft_buffer);
|
||||
|
||||
filesource_free(&fsrc);
|
||||
srslte_filesource_free(&fsrc);
|
||||
for (i=0;i<SRSLTE_MAX_PORTS;i++) {
|
||||
free(ce[i]);
|
||||
}
|
||||
|
@ -206,7 +206,7 @@ int main(int argc, char **argv) {
|
|||
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);
|
||||
|
||||
|
|
|
@ -52,7 +52,7 @@ uint16_t rnti = SRSLTE_SIRNTI;
|
|||
int max_frames = 10;
|
||||
|
||||
dci_format_t dci_format = Format1A;
|
||||
filesource_t fsrc;
|
||||
srslte_filesource_t fsrc;
|
||||
pdcch_t pdcch;
|
||||
cf_t *input_buffer, *fft_buffer, *ce[SRSLTE_MAX_PORTS];
|
||||
regs_t regs;
|
||||
|
@ -124,7 +124,7 @@ void parse_args(int argc, char **argv) {
|
|||
int base_init() {
|
||||
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);
|
||||
exit(-1);
|
||||
}
|
||||
|
@ -182,12 +182,12 @@ int base_init() {
|
|||
void base_free() {
|
||||
int i;
|
||||
|
||||
filesource_free(&fsrc);
|
||||
srslte_filesource_free(&fsrc);
|
||||
|
||||
free(input_buffer);
|
||||
free(fft_buffer);
|
||||
|
||||
filesource_free(&fsrc);
|
||||
srslte_filesource_free(&fsrc);
|
||||
for (i=0;i<SRSLTE_MAX_PORTS;i++) {
|
||||
free(ce[i]);
|
||||
}
|
||||
|
@ -222,7 +222,7 @@ int main(int argc, char **argv) {
|
|||
ret = -1;
|
||||
frame_cnt = 0;
|
||||
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);
|
||||
|
||||
|
@ -231,7 +231,7 @@ int main(int argc, char **argv) {
|
|||
/* Get channel estimates for each port */
|
||||
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,
|
||||
ce, srslte_chest_dl_get_noise_estimate(&chest),
|
||||
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);
|
||||
}
|
||||
|
||||
for (i=0;i<nof_locations && crc_rem != rnti;i++) {
|
||||
if (pdcch_decode_msg(&pdcch, &dci_msg, &locations[i], dci_format, &crc_rem)) {
|
||||
for (i=0;i<nof_locations && srslte_crc_rem != rnti;i++) {
|
||||
if (pdcch_decode_msg(&pdcch, &dci_msg, &locations[i], dci_format, &srslte_crc_rem)) {
|
||||
fprintf(stderr, "Error decoding DCI msg\n");
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
if (crc_rem == rnti) {
|
||||
if (srslte_crc_rem == rnti) {
|
||||
dci_msg_type_t type;
|
||||
if (dci_msg_get_type(&dci_msg, &type, cell.nof_prb, rnti)) {
|
||||
fprintf(stderr, "Can't get DCI message type\n");
|
||||
|
|
|
@ -195,16 +195,16 @@ int main(int argc, char **argv) {
|
|||
fprintf(stderr, "Error extracting LLRs\n");
|
||||
goto quit;
|
||||
}
|
||||
uint16_t crc_rem;
|
||||
if (pdcch_decode_msg(&pdcch, &dci_tmp, &dci_locations[i], Format1, &crc_rem)) {
|
||||
uint16_t srslte_crc_rem;
|
||||
if (pdcch_decode_msg(&pdcch, &dci_tmp, &dci_locations[i], Format1, &srslte_crc_rem)) {
|
||||
fprintf(stderr, "Error decoding DCI message\n");
|
||||
goto quit;
|
||||
}
|
||||
if (crc_rem >= 1234 && crc_rem < 1234 + nof_dcis) {
|
||||
crc_rem -= 1234;
|
||||
memcpy(&dci_rx[crc_rem], &dci_tmp, sizeof(dci_msg_t));
|
||||
if (srslte_crc_rem >= 1234 && srslte_crc_rem < 1234 + nof_dcis) {
|
||||
srslte_crc_rem -= 1234;
|
||||
memcpy(&dci_rx[srslte_crc_rem], &dci_tmp, sizeof(dci_msg_t));
|
||||
} else {
|
||||
printf("Received invalid DCI CRC 0x%x\n", crc_rem);
|
||||
printf("Received invalid DCI CRC 0x%x\n", srslte_crc_rem);
|
||||
goto quit;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -162,13 +162,13 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
|
|||
formats = ue_formats;
|
||||
nof_formats = nof_ue_formats;
|
||||
}
|
||||
uint16_t crc_rem=0;
|
||||
uint16_t srslte_crc_rem=0;
|
||||
dci_msg_t dci_msg;
|
||||
bzero(&dci_msg, sizeof(dci_msg_t));
|
||||
|
||||
for (int f=0;f<nof_formats;f++) {
|
||||
for (i=0;i<nof_locations && crc_rem != rnti;i++) {
|
||||
if (pdcch_decode_msg(&pdcch, &dci_msg, &locations[i], formats[f], &crc_rem)) {
|
||||
for (i=0;i<nof_locations && srslte_crc_rem != rnti;i++) {
|
||||
if (pdcch_decode_msg(&pdcch, &dci_msg, &locations[i], formats[f], &srslte_crc_rem)) {
|
||||
fprintf(stderr, "Error decoding DCI msg\n");
|
||||
return;
|
||||
}
|
||||
|
@ -176,7 +176,7 @@ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
|
|||
}
|
||||
|
||||
if (nlhs >= 1) {
|
||||
plhs[0] = mxCreateLogicalScalar(crc_rem == rnti);
|
||||
plhs[0] = mxCreateLogicalScalar(srslte_crc_rem == rnti);
|
||||
}
|
||||
int nof_bits = (regs_pdcch_nregs(®s, cfi) / 9) * 72;
|
||||
if (nlhs >= 2) {
|
||||
|
|
|
@ -55,7 +55,7 @@ int max_frames = 10;
|
|||
uint32_t sf_idx = 0;
|
||||
|
||||
dci_format_t dci_format = Format1A;
|
||||
filesource_t fsrc;
|
||||
srslte_filesource_t fsrc;
|
||||
pdcch_t pdcch;
|
||||
pdsch_t pdsch;
|
||||
harq_t harq_process;
|
||||
|
@ -133,7 +133,7 @@ void parse_args(int argc, char **argv) {
|
|||
int base_init() {
|
||||
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);
|
||||
exit(-1);
|
||||
}
|
||||
|
@ -203,12 +203,12 @@ int base_init() {
|
|||
void base_free() {
|
||||
int i;
|
||||
|
||||
filesource_free(&fsrc);
|
||||
srslte_filesource_free(&fsrc);
|
||||
|
||||
free(input_buffer);
|
||||
free(fft_buffer);
|
||||
|
||||
filesource_free(&fsrc);
|
||||
srslte_filesource_free(&fsrc);
|
||||
for (i=0;i<SRSLTE_MAX_PORTS;i++) {
|
||||
free(ce[i]);
|
||||
}
|
||||
|
@ -253,7 +253,7 @@ int main(int argc, char **argv) {
|
|||
ret = -1;
|
||||
nof_frames = 0;
|
||||
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);
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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)) {
|
||||
fprintf(stderr, "Error extracting LLRs\n");
|
||||
return -1;
|
||||
}
|
||||
for (i=0;i<nof_locations && crc_rem != rnti;i++) {
|
||||
if (pdcch_decode_msg(&pdcch, &dci_msg, &locations[i], dci_format, &crc_rem)) {
|
||||
for (i=0;i<nof_locations && srslte_crc_rem != rnti;i++) {
|
||||
if (pdcch_decode_msg(&pdcch, &dci_msg, &locations[i], dci_format, &srslte_crc_rem)) {
|
||||
fprintf(stderr, "Error decoding DCI msg\n");
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
if (crc_rem == rnti) {
|
||||
if (srslte_crc_rem == rnti) {
|
||||
if (dci_msg_to_ra_dl(&dci_msg, rnti, cell, cfi, &ra_dl)) {
|
||||
fprintf(stderr, "Error unpacking PDSCH scheduling DCI message\n");
|
||||
goto goout;
|
||||
|
|
|
@ -51,7 +51,7 @@ int numsubframe = 0;
|
|||
|
||||
FILE *fmatlab = NULL;
|
||||
|
||||
filesource_t fsrc;
|
||||
srslte_filesource_t fsrc;
|
||||
cf_t *input_buffer, *fft_buffer, *ce[SRSLTE_MAX_PORTS];
|
||||
phich_t phich;
|
||||
regs_t regs;
|
||||
|
@ -129,7 +129,7 @@ void parse_args(int argc, char **argv) {
|
|||
int base_init() {
|
||||
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);
|
||||
exit(-1);
|
||||
}
|
||||
|
@ -193,7 +193,7 @@ int base_init() {
|
|||
void base_free() {
|
||||
int i;
|
||||
|
||||
filesource_free(&fsrc);
|
||||
srslte_filesource_free(&fsrc);
|
||||
if (fmatlab) {
|
||||
fclose(fmatlab);
|
||||
}
|
||||
|
@ -201,7 +201,7 @@ void base_free() {
|
|||
free(input_buffer);
|
||||
free(fft_buffer);
|
||||
|
||||
filesource_free(&fsrc);
|
||||
srslte_filesource_free(&fsrc);
|
||||
for (i=0;i<SRSLTE_MAX_PORTS;i++) {
|
||||
free(ce[i]);
|
||||
}
|
||||
|
@ -232,7 +232,7 @@ int main(int argc, char **argv) {
|
|||
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);
|
||||
|
||||
|
|
|
@ -31,11 +31,11 @@
|
|||
#include <assert.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);
|
||||
}
|
||||
|
||||
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;
|
||||
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);
|
||||
}
|
||||
|
||||
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;
|
||||
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;
|
||||
|
||||
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;
|
||||
assert (len + offset <= s->len);
|
||||
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 */
|
||||
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;
|
||||
assert (len + offset <= s->len);
|
||||
for (i = 0; i < len; i++) {
|
||||
|
@ -96,22 +96,22 @@ int compute_sequences(scrambling_hl* h) {
|
|||
|
||||
switch (h->init.channel) {
|
||||
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);
|
||||
case SCRAMBLING_PDSCH:
|
||||
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);
|
||||
}
|
||||
return 0;
|
||||
case SCRAMBLING_PCFICH:
|
||||
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;
|
||||
case SCRAMBLING_PDCCH:
|
||||
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;
|
||||
case SCRAMBLING_PMCH:
|
||||
|
@ -139,7 +139,7 @@ int scrambling_work(scrambling_hl* hl) {
|
|||
} else {
|
||||
sf = hl->ctrl_in.subframe;
|
||||
}
|
||||
sequence_t *seq = &hl->obj.seq[sf];
|
||||
srslte_sequence_t *seq = &hl->obj.seq[sf];
|
||||
|
||||
if (hl->init.hard) {
|
||||
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 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;
|
||||
}
|
||||
|
|
|
@ -36,7 +36,7 @@
|
|||
|
||||
#include "srslte/srslte.h"
|
||||
|
||||
char *sequence_name = NULL;
|
||||
char *srslte_sequence_name = NULL;
|
||||
bool do_floats = false;
|
||||
srslte_cp_t cp = SRSLTE_SRSLTE_CP_NORM;
|
||||
int cell_id = -1;
|
||||
|
@ -61,7 +61,7 @@ void parse_args(int argc, char **argv) {
|
|||
do_floats = true;
|
||||
break;
|
||||
case 's':
|
||||
sequence_name = argv[optind];
|
||||
srslte_sequence_name = argv[optind];
|
||||
break;
|
||||
default:
|
||||
usage(argv[0]);
|
||||
|
@ -72,15 +72,15 @@ void parse_args(int argc, char **argv) {
|
|||
usage(argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
if (!sequence_name) {
|
||||
if (!srslte_sequence_name) {
|
||||
usage(argv[0]);
|
||||
exit(-1);
|
||||
}
|
||||
}
|
||||
|
||||
int init_sequence(sequence_t *seq, char *name) {
|
||||
int init_sequence(srslte_sequence_t *seq, char *name) {
|
||||
if (!strcmp(name, "PBCH")) {
|
||||
return sequence_pbch(seq, cp, cell_id);
|
||||
return srslte_sequence_pbch(seq, cp, cell_id);
|
||||
} else {
|
||||
fprintf(stderr, "Unsupported sequence name %s\n", name);
|
||||
return -1;
|
||||
|
@ -90,14 +90,14 @@ int init_sequence(sequence_t *seq, char *name) {
|
|||
|
||||
int main(int argc, char **argv) {
|
||||
int i;
|
||||
sequence_t seq;
|
||||
srslte_sequence_t seq;
|
||||
uint8_t *input_b, *scrambled_b;
|
||||
float *input_f, *scrambled_f;
|
||||
|
||||
parse_args(argc, argv);
|
||||
|
||||
if (init_sequence(&seq, sequence_name) == -1) {
|
||||
fprintf(stderr, "Error initiating sequence %s\n", sequence_name);
|
||||
if (init_sequence(&seq, srslte_sequence_name) == -1) {
|
||||
fprintf(stderr, "Error initiating sequence %s\n", srslte_sequence_name);
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
|
@ -160,6 +160,6 @@ int main(int argc, char **argv) {
|
|||
free(scrambled_f);
|
||||
}
|
||||
printf("Ok\n");
|
||||
sequence_free(&seq);
|
||||
srslte_sequence_free(&seq);
|
||||
exit(0);
|
||||
}
|
||||
|
|
|
@ -39,13 +39,13 @@
|
|||
float tmp_pss_corr[32*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);
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
|
|
|
@ -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];
|
||||
uint32_t nof_locations = pdcch_ue_locations(&q->pdcch, locations, MAX_CANDIDATES, sf_idx, cfi, rnti);
|
||||
uint16_t crc_rem = 0;
|
||||
for (uint32_t i=0;i<nof_locations && crc_rem != rnti;i++) {
|
||||
if (pdcch_decode_msg(&q->pdcch, dci_msg, &locations[i], Format0, &crc_rem)) {
|
||||
uint16_t srslte_crc_rem = 0;
|
||||
for (uint32_t i=0;i<nof_locations && srslte_crc_rem != rnti;i++) {
|
||||
if (pdcch_decode_msg(&q->pdcch, dci_msg, &locations[i], Format0, &srslte_crc_rem)) {
|
||||
fprintf(stderr, "Error decoding DCI msg\n");
|
||||
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)
|
||||
|
@ -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_location_t locations[MAX_CANDIDATES];
|
||||
uint32_t nof_locations;
|
||||
uint16_t crc_rem;
|
||||
uint16_t srslte_crc_rem;
|
||||
int ret = SRSLTE_ERROR;
|
||||
uint32_t nof_formats;
|
||||
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 */
|
||||
crc_rem = 0;
|
||||
srslte_crc_rem = 0;
|
||||
uint32_t found_dci = 0;
|
||||
for (int f=0;f<nof_formats && !found_dci;f++) {
|
||||
INFO("Trying format %s\n", dci_format_string(formats[f]));
|
||||
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");
|
||||
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++;
|
||||
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
Loading…
Reference in New Issue