mirror
/
sdrangel
kopia lustrzana https://github.com/f4exb/sdrangel
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

PVS-Studio analys fixes: libfreedv serious issues

pull/375/head
f4exb 2019-06-14 18:08:38 +02:00
rodzic 5d7aa89304
commit 8eb0dcf267
7 zmienionych plików z 214 dodań i 136 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

172
libfreedv/freedv_api.cpp
Wyświetl plik

@ -119,32 +119,41 @@ struct freedv *freedv_open_advanced(int mode, struct freedv_advanced *adv) {
if ((mode != FREEDV_MODE_1600) && (mode != FREEDV_MODE_700) && if ((mode != FREEDV_MODE_1600) && (mode != FREEDV_MODE_700) &&
(mode != FREEDV_MODE_700B) && (mode != FREEDV_MODE_2400A) && (mode != FREEDV_MODE_700B) && (mode != FREEDV_MODE_2400A) &&
(mode != FREEDV_MODE_2400B) && (mode != FREEDV_MODE_800XA) && (mode != FREEDV_MODE_2400B) && (mode != FREEDV_MODE_800XA) &&
(mode != FREEDV_MODE_700C) && (mode != FREEDV_MODE_700D) ) (mode != FREEDV_MODE_700C) && (mode != FREEDV_MODE_700D)) {
return NULL; return nullptr;
}
f = (struct freedv*) malloc(sizeof(struct freedv)); f = (struct freedv*) malloc(sizeof(struct freedv));
if (f == NULL)
return NULL; if (f == nullptr) {
return nullptr;
}
f->mode = mode; f->mode = mode;
f->verbose = 0; f->verbose = 0;
f->test_frames = f->smooth_symbols = 0; f->test_frames = f->smooth_symbols = 0;
f->freedv_put_error_pattern = NULL; f->freedv_put_error_pattern = nullptr;
f->error_pattern_callback_state = NULL; f->error_pattern_callback_state = nullptr;
f->n_protocol_bits = 0; f->n_protocol_bits = 0;
f->frames = 0; f->frames = 0;
/* Init states for this mode, and set up samples in/out -----------------------------------------*/ /* Init states for this mode, and set up samples in/out -----------------------------------------*/
if (mode == FREEDV_MODE_1600) { if (mode == FREEDV_MODE_1600)
{
f->snr_squelch_thresh = 2.0; f->snr_squelch_thresh = 2.0;
f->squelch_en = 1; f->squelch_en = 1;
Nc = 16; Nc = 16;
f->tx_sync_bit = 0; f->tx_sync_bit = 0;
codec2_mode = CODEC2_MODE_1300; codec2_mode = CODEC2_MODE_1300;
f->fdmdv = fdmdv_create(Nc); f->fdmdv = fdmdv_create(Nc);
if (f->fdmdv == NULL)
return NULL; if (f->fdmdv == nullptr)
{
free(f);
return nullptr;
}
golay23_init(); golay23_init();
f->nin = FDMDV_NOM_SAMPLES_PER_FRAME; f->nin = FDMDV_NOM_SAMPLES_PER_FRAME;
f->n_nom_modem_samples = 2*FDMDV_NOM_SAMPLES_PER_FRAME; f->n_nom_modem_samples = 2*FDMDV_NOM_SAMPLES_PER_FRAME;
@ -153,22 +162,32 @@ struct freedv *freedv_open_advanced(int mode, struct freedv_advanced *adv) {
f->modem_sample_rate = FS; f->modem_sample_rate = FS;
nbit = fdmdv_bits_per_frame(f->fdmdv); nbit = fdmdv_bits_per_frame(f->fdmdv);
f->fdmdv_bits = (int*) malloc(nbit*sizeof(int)); f->fdmdv_bits = (int*) malloc(nbit*sizeof(int));
if (f->fdmdv_bits == NULL)
return NULL; if (f->fdmdv_bits == nullptr) {
return nullptr;
}
nbit = 2*fdmdv_bits_per_frame(f->fdmdv); nbit = 2*fdmdv_bits_per_frame(f->fdmdv);
f->tx_bits = (int*) malloc(nbit*sizeof(int)); f->tx_bits = (int*) malloc(nbit*sizeof(int));
f->rx_bits = (int*) malloc(nbit*sizeof(int)); f->rx_bits = (int*) malloc(nbit*sizeof(int));
if ((f->tx_bits == NULL) || (f->rx_bits == NULL)) {
if (f->tx_bits != NULL) { if ((f->tx_bits == nullptr) || (f->rx_bits == nullptr))
{
if (f->tx_bits != nullptr)
{
free(f->tx_bits); free(f->tx_bits);
f->tx_bits = NULL; f->tx_bits = nullptr;
} }
if (f->rx_bits != NULL) {
if (f->rx_bits != nullptr)
{
free(f->rx_bits); free(f->rx_bits);
f->rx_bits = NULL; f->rx_bits = nullptr;
} }
return NULL;
return nullptr;
} }
f->evenframe = 0; f->evenframe = 0;
f->sz_error_pattern = fdmdv_error_pattern_size(f->fdmdv); f->sz_error_pattern = fdmdv_error_pattern_size(f->fdmdv);
} }
@ -310,8 +329,8 @@ struct freedv *freedv_open_advanced(int mode, struct freedv_advanced *adv) {
} }
#endif #endif
if ((mode == FREEDV_MODE_2400A) || (mode == FREEDV_MODE_2400B)) { if ((mode == FREEDV_MODE_2400A) || (mode == FREEDV_MODE_2400B))
{
/* Set up the C2 mode */ /* Set up the C2 mode */
codec2_mode = CODEC2_MODE_1300; codec2_mode = CODEC2_MODE_1300;
/* Set the number of protocol bits */ /* Set the number of protocol bits */
@ -320,22 +339,25 @@ struct freedv *freedv_open_advanced(int mode, struct freedv_advanced *adv) {
f->ext_vco = 0; f->ext_vco = 0;
} }
if (mode == FREEDV_MODE_2400A) { if (mode == FREEDV_MODE_2400A)
{
/* Create the framer|deframer */ /* Create the framer|deframer */
f->deframer = fvhff_create_deframer(FREEDV_VHF_FRAME_A,0); f->deframer = fvhff_create_deframer(FREEDV_VHF_FRAME_A, 0);
if(f->deframer == NULL)
return NULL; if (f->deframer == nullptr) {
return nullptr;
}
f->fsk = fsk_create_hbr(48000,1200,10,4,1200,1200); f->fsk = fsk_create_hbr(48000,1200,10,4,1200,1200);
/* Note: fsk expects tx/rx bits as an array of uint8_ts, not ints */ if (f->fsk == nullptr)
f->tx_bits = (int*) malloc(f->fsk->Nbits*sizeof(uint8_t)); {
if(f->fsk == NULL){
fvhff_destroy_deframer(f->deframer); fvhff_destroy_deframer(f->deframer);
return NULL; return nullptr;
} }
/* Note: fsk expects tx/rx bits as an array of uint8_ts, not ints */
f->tx_bits = (int*) malloc(f->fsk->Nbits*sizeof(int));
f->n_nom_modem_samples = f->fsk->N; f->n_nom_modem_samples = f->fsk->N;
f->n_max_modem_samples = f->fsk->N + (f->fsk->Ts); f->n_max_modem_samples = f->fsk->N + (f->fsk->Ts);
f->n_nat_modem_samples = f->fsk->N; f->n_nat_modem_samples = f->fsk->N;
@ -343,53 +365,63 @@ struct freedv *freedv_open_advanced(int mode, struct freedv_advanced *adv) {
f->modem_sample_rate = 48000; f->modem_sample_rate = 48000;
f->modem_symbol_rate = 1200; f->modem_symbol_rate = 1200;
/* Malloc something to appease freedv_init and freedv_destroy */ /* Malloc something to appease freedv_init and freedv_destroy */
f->codec_bits = (int*) malloc(1); f->codec_bits = (int*) malloc(1*sizeof(int));
} }
if (mode == FREEDV_MODE_2400B) { if (mode == FREEDV_MODE_2400B)
{
/* Create the framer|deframer */ /* Create the framer|deframer */
f->deframer = fvhff_create_deframer(FREEDV_VHF_FRAME_A,1); f->deframer = fvhff_create_deframer(FREEDV_VHF_FRAME_A, 1);
if(f->deframer == NULL) {
if (f->codec_bits != NULL) { free(f->codec_bits); } if (f->deframer == nullptr)
return NULL; {
if (f->codec_bits != nullptr) {
free(f->codec_bits);
}
return nullptr;
} }
f->fmfsk = fmfsk_create(48000,2400); f->fmfsk = fmfsk_create(48000, 2400);
if(f->fmfsk == NULL){ if (f->fmfsk == nullptr)
{
fvhff_destroy_deframer(f->deframer); fvhff_destroy_deframer(f->deframer);
return NULL; return nullptr;
} }
/* Note: fsk expects tx/rx bits as an array of uint8_ts, not ints */
f->tx_bits = (int*) malloc(f->fmfsk->nbit*sizeof(uint8_t));
/* Note: fsk expects tx/rx bits as an array of uint8_ts, not ints */
f->tx_bits = (int*) malloc(f->fmfsk->nbit*sizeof(int));
f->n_nom_modem_samples = f->fmfsk->N; f->n_nom_modem_samples = f->fmfsk->N;
f->n_max_modem_samples = f->fmfsk->N + (f->fmfsk->Ts); f->n_max_modem_samples = f->fmfsk->N + (f->fmfsk->Ts);
f->n_nat_modem_samples = f->fmfsk->N; f->n_nat_modem_samples = f->fmfsk->N;
f->nin = fmfsk_nin(f->fmfsk); f->nin = fmfsk_nin(f->fmfsk);
f->modem_sample_rate = 48000; f->modem_sample_rate = 48000;
/* Malloc something to appease freedv_init and freedv_destroy */ /* Malloc something to appease freedv_init and freedv_destroy */
f->codec_bits = (int*) malloc(1); f->codec_bits = (int*) malloc(1*sizeof(int));
} }
#ifdef CODEC2_MODE_700C #ifdef CODEC2_MODE_700C
if (mode == FREEDV_MODE_800XA) { if (mode == FREEDV_MODE_800XA)
{
/* Create the framer|deframer */ /* Create the framer|deframer */
f->deframer = fvhff_create_deframer(FREEDV_HF_FRAME_B,0); f->deframer = fvhff_create_deframer(FREEDV_HF_FRAME_B, 0);
if(f->deframer == NULL)
return NULL;
f->fsk = fsk_create_hbr(8000,400,10,4,800,400); if (f->deframer == nullptr) {
fsk_set_nsym(f->fsk,32); return nullptr;
/* Note: fsk expects tx/rx bits as an array of uint8_ts, not ints */
f->tx_bits = (int*) malloc(f->fsk->Nbits*sizeof(uint8_t));
if(f->fsk == NULL){
fvhff_destroy_deframer(f->deframer);
return NULL;
} }
f->fsk = fsk_create_hbr(8000, 400, 10, 4, 800, 400);
fsk_set_nsym(f->fsk,32);
if (f->fsk == nullptr)
{
fvhff_destroy_deframer(f->deframer);
return nullptr;
}
/* Note: fsk expects tx/rx bits as an array of uint8_ts, not ints */
f->tx_bits = (int*) malloc(f->fsk->Nbits*sizeof(int));
f->n_nom_modem_samples = f->fsk->N; f->n_nom_modem_samples = f->fsk->N;
f->n_max_modem_samples = f->fsk->N + (f->fsk->Ts); f->n_max_modem_samples = f->fsk->N + (f->fsk->Ts);
f->n_nat_modem_samples = f->fsk->N; f->n_nat_modem_samples = f->fsk->N;
@ -398,7 +430,7 @@ struct freedv *freedv_open_advanced(int mode, struct freedv_advanced *adv) {
f->modem_symbol_rate = 400; f->modem_symbol_rate = 400;
/* Malloc something to appease freedv_init and freedv_destroy */ /* Malloc something to appease freedv_init and freedv_destroy */
f->codec_bits = (int*) malloc(1); f->codec_bits = (int*) malloc(1*sizeof(int));
f->n_protocol_bits = 0; f->n_protocol_bits = 0;
codec2_mode = CODEC2_MODE_700C; codec2_mode = CODEC2_MODE_700C;
@ -2410,15 +2442,18 @@ void freedv_set_carrier_ampl(struct freedv *freedv, int c, float ampl) {
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
int freedv_set_alt_modem_samp_rate(struct freedv *f, int samp_rate){ int freedv_set_alt_modem_samp_rate(struct freedv *f, int samp_rate)
if(f->mode == FREEDV_MODE_2400A){ {
if(samp_rate == 24000 || samp_rate == 48000 || samp_rate == 96000){ if (f->mode == FREEDV_MODE_2400A)
{
if (samp_rate == 24000 || samp_rate == 48000 || samp_rate == 96000)
{
fsk_destroy(f->fsk); fsk_destroy(f->fsk);
f->fsk = fsk_create_hbr(samp_rate,1200,10,4,1200,1200); f->fsk = fsk_create_hbr(samp_rate, 1200, 10, 4, 1200, 1200);
free(f->tx_bits); free(f->tx_bits);
/* Note: fsk expects tx/rx bits as an array of uint8_ts, not ints */ /* Note: fsk expects tx/rx bits as an array of uint8_ts, not ints */
f->tx_bits = (int*) malloc(f->fsk->Nbits*sizeof(uint8_t)); f->tx_bits = (int*) malloc(f->fsk->Nbits*sizeof(int));
f->n_nom_modem_samples = f->fsk->N; f->n_nom_modem_samples = f->fsk->N;
f->n_max_modem_samples = f->fsk->N + (f->fsk->Ts); f->n_max_modem_samples = f->fsk->N + (f->fsk->Ts);
@ -2426,14 +2461,21 @@ int freedv_set_alt_modem_samp_rate(struct freedv *f, int samp_rate){
f->nin = fsk_nin(f->fsk); f->nin = fsk_nin(f->fsk);
f->modem_sample_rate = samp_rate; f->modem_sample_rate = samp_rate;
return 0; return 0;
}else }
return -1; else
}else if(f->mode == FREEDV_MODE_2400B){ {
if(samp_rate == 48000 || samp_rate == 96000){
return -1;
}else
return -1; return -1;
}
} }
else if (f->mode == FREEDV_MODE_2400B)
{
if (samp_rate == 48000 || samp_rate == 96000) {
return -1;
} else {
return -1;
}
}
return -1; return -1;
} }

16
libfreedv/freedv_data_channel.cpp
Wyświetl plik

@ -93,16 +93,22 @@ static unsigned char fdc_crc4(unsigned char *buffer, std::size_t len)
unsigned char crc = 0x0f; unsigned char crc = 0x0f;
std::size_t i; std::size_t i;
for (i = 0; i < len; i++, buffer++) { for (i = 0; i < len; i++, buffer++)
{
int shift; int shift;
for (shift = 7; shift <= 0; shift--) { for (shift = 7; shift >= 0; shift--)
{
crc <<= 1; crc <<= 1;
if ((*buffer >> shift) & 0x1)
if ((*buffer >> shift) & 0x1) {
crc |= 1; crc |= 1;
if (crc & 0x10) }
if (crc & 0x10) {
crc ^= 0x03; crc ^= 0x03;
} }
}
} }
return crc & 0x0f; return crc & 0x0f;

43
libfreedv/freedv_filter.cpp
Wyświetl plik

@ -19,6 +19,7 @@
#include <string.h> #include <string.h>
#include <math.h> #include <math.h>
#include <complex.h> #include <complex.h>
#include <algorithm>
#include "freedv_filter.h" #include "freedv_filter.h"
#include "freedv_filter_coef.h" #include "freedv_filter_coef.h"
@ -45,16 +46,17 @@ namespace FreeDV
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
void quisk_filt_cfInit(struct quisk_cfFilter * filter, float * coefs, int taps) { void quisk_filt_cfInit(struct quisk_cfFilter * filter, float * coefs, int taps)
{
// Prepare a new filter using coefs and taps. Samples are complex. Coefficients can // Prepare a new filter using coefs and taps. Samples are complex. Coefficients can
// be real or complex. // be real or complex.
filter->dCoefs = coefs; filter->dCoefs = coefs;
filter->cpxCoefs = NULL; filter->cpxCoefs = nullptr;
filter->cSamples = (std::complex<float> *) malloc(taps * sizeof(std::complex<float>)); filter->cSamples = new std::complex<float>[taps];
memset(filter->cSamples, 0, taps * sizeof(std::complex<float>)); std::fill(filter->cSamples, filter->cSamples + taps, std::complex<float>{0.0, 0.0});
filter->ptcSamp = filter->cSamples; filter->ptcSamp = filter->cSamples;
filter->nTaps = taps; filter->nTaps = taps;
filter->cBuf = NULL; filter->cBuf = nullptr;
filter->nBuf = 0; filter->nBuf = 0;
filter->decim_index = 0; filter->decim_index = 0;
} }
@ -70,20 +72,24 @@ void quisk_filt_cfInit(struct quisk_cfFilter * filter, float * coefs, int taps)
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
void quisk_filt_destroy(struct quisk_cfFilter * filter) { void quisk_filt_destroy(struct quisk_cfFilter * filter)
if (filter->cSamples) { {
free(filter->cSamples); if (filter->cSamples)
filter->cSamples = NULL; {
delete[] filter->cSamples;
filter->cSamples = nullptr;
} }
if (filter->cBuf) { if (filter->cBuf)
free(filter->cBuf); {
filter->cBuf = NULL; delete[] filter->cBuf;
filter->cBuf = nullptr;
} }
if (filter->cpxCoefs) { if (filter->cpxCoefs)
free(filter->cpxCoefs); {
filter->cpxCoefs = NULL; delete[] filter->cpxCoefs;
filter->cpxCoefs = nullptr;
} }
} }
@ -115,7 +121,7 @@ int quisk_cfInterpDecim(std::complex<float> * cSamples, int count, struct quisk_
if (filter->cBuf) if (filter->cBuf)
free(filter->cBuf); free(filter->cBuf);
filter->cBuf = (std::complex<float> *) malloc(filter->nBuf * sizeof(std::complex<float>)); filter->cBuf = new std::complex<float>[filter->nBuf];
} }
memcpy(filter->cBuf, cSamples, count * sizeof(std::complex<float>)); memcpy(filter->cBuf, cSamples, count * sizeof(std::complex<float>));
@ -232,8 +238,9 @@ void quisk_cfTune(struct quisk_cfFilter * filter, float freq) {
float D, tune; float D, tune;
int i; int i;
if ( ! filter->cpxCoefs) if ( ! filter->cpxCoefs) {
filter->cpxCoefs = (std::complex<float> *) malloc(filter->nTaps * sizeof(std::complex<float>)); filter->cpxCoefs = new std::complex<float>[filter->nTaps];
}
tune = 2.0 * M_PI * freq; tune = 2.0 * M_PI * freq;
D = (filter->nTaps - 1.0) / 2.0; D = (filter->nTaps - 1.0) / 2.0;

49
libfreedv/freedv_vhf_framing.cpp
Wyświetl plik

@ -294,46 +294,65 @@ void fvhff_frame_data_bits(struct freedv_vhf_deframer * def, int frame_type,
} }
/* Init and allocate memory for a freedv-vhf framer/deframer */ /* Init and allocate memory for a freedv-vhf framer/deframer */
struct freedv_vhf_deframer * fvhff_create_deframer(uint8_t frame_type, int enable_bit_flip){ struct freedv_vhf_deframer * fvhff_create_deframer(uint8_t frame_type, int enable_bit_flip)
{
struct freedv_vhf_deframer * deframer; struct freedv_vhf_deframer * deframer;
uint8_t *bits,*invbits; uint8_t *bits,*invbits;
int frame_size; int frame_size;
int uw_size; int uw_size;
assert( (frame_type == FREEDV_VHF_FRAME_A) || (frame_type == FREEDV_HF_FRAME_B) ); assert((frame_type == FREEDV_VHF_FRAME_A) || (frame_type == FREEDV_HF_FRAME_B));
/* It's a Type A frame */ /* It's a Type A frame */
if(frame_type == FREEDV_VHF_FRAME_A){ if (frame_type == FREEDV_VHF_FRAME_A)
{
frame_size = 96; frame_size = 96;
uw_size = 16; uw_size = 16;
}else if(frame_type == FREEDV_HF_FRAME_B){ }
else if (frame_type == FREEDV_HF_FRAME_B)
{
frame_size = 64; frame_size = 64;
uw_size = 8; uw_size = 8;
}else{ }
return NULL; else
{
return nullptr;
} }
/* Allocate memory for the thing */ /* Allocate memory for the thing */
deframer = (freedv_vhf_deframer*) malloc(sizeof(struct freedv_vhf_deframer)); deframer = (freedv_vhf_deframer*) malloc(sizeof(struct freedv_vhf_deframer));
if(deframer == NULL)
return NULL; if (deframer == nullptr) {
return nullptr;
}
/* Allocate the not-bit buffer */ /* Allocate the not-bit buffer */
if(enable_bit_flip){ if (enable_bit_flip)
{
invbits = (uint8_t*) malloc(sizeof(uint8_t)*frame_size); invbits = (uint8_t*) malloc(sizeof(uint8_t)*frame_size);
if(invbits == NULL) {
if (invbits == nullptr)
{
free(deframer); free(deframer);
return NULL; return nullptr;
} }
}else{ }
invbits = NULL; else
{
invbits = nullptr;
} }
/* Allocate the bit buffer */ /* Allocate the bit buffer */
bits = (uint8_t*) malloc(sizeof(uint8_t)*frame_size); bits = (uint8_t*) malloc(sizeof(uint8_t)*frame_size);
if(bits == NULL) {
if (bits == nullptr)
{
if (invbits) {
free(invbits);
}
free(deframer); free(deframer);
return NULL; return nullptr;
} }
deframer->bits = bits; deframer->bits = bits;

12
libfreedv/fsk.cpp
Wyświetl plik

@ -671,7 +671,8 @@ void fsk_demod_freq_est(struct FSK *fsk, COMP fsk_in[],float *freqs,int M){
free(fftout); free(fftout);
} }
void fsk2_demod(struct FSK *fsk, uint8_t rx_bits[], float rx_sd[], COMP fsk_in[]){ void fsk2_demod(struct FSK *fsk, uint8_t rx_bits[], float rx_sd[], COMP fsk_in[])
{
int N = fsk->N; int N = fsk->N;
int Ts = fsk->Ts; int Ts = fsk->Ts;
int Rs = fsk->Rs; int Rs = fsk->Rs;
@ -687,7 +688,7 @@ void fsk2_demod(struct FSK *fsk, uint8_t rx_bits[], float rx_sd[], COMP fsk_in[]
COMP* *f_int = new COMP*[M]; /* Filtered and downsampled symbol tones */ COMP* *f_int = new COMP*[M]; /* Filtered and downsampled symbol tones */
COMP *t = new COMP[M]; /* complex number temps */ COMP *t = new COMP[M]; /* complex number temps */
COMP t_c; /* another complex temp */ COMP t_c; /* another complex temp */
COMP *phi_c = new COMP[M]; COMP *phi_c = new COMP[M];
COMP phi_ft; COMP phi_ft;
int nold = Nmem-nin; int nold = Nmem-nin;
@ -863,7 +864,12 @@ void fsk2_demod(struct FSK *fsk, uint8_t rx_bits[], float rx_sd[], COMP fsk_in[]
/* Check for NaNs in the fine timing estimate, return if found */ /* Check for NaNs in the fine timing estimate, return if found */
/* otherwise segfaults happen */ /* otherwise segfaults happen */
if( std::isnan(t_c.real) || std::isnan(t_c.imag)){ if (std::isnan(t_c.real) || std::isnan(t_c.imag))
{
free(f_intbuf_m);
delete[] dphi;
delete[] phi_c;
delete[] t;
return; return;
} }

3
libfreedv/gp_interleaver.cpp
Wyświetl plik

@ -68,7 +68,8 @@ int choose_interleaver_b(int Nbits)
{ {
unsigned int i; unsigned int i;
for(i=0; i<sizeof(b_table)/(2*sizeof(int)); i+=2) { for (i = 0; i < sizeof(b_table)/(2*sizeof(int)); i += 2)
{
if (b_table[i] == Nbits) { if (b_table[i] == Nbits) {
return b_table[i+1]; return b_table[i+1];
} }

55
libfreedv/ofdm.cpp
Wyświetl plik

@ -222,14 +222,10 @@ struct OFDM *ofdm_create(const struct OFDM_CONFIG *config) {
ofdm_nuwbits = (ofdm_ns - 1) * ofdm_bps - ofdm_ntxtbits; // 10 ofdm_nuwbits = (ofdm_ns - 1) * ofdm_bps - ofdm_ntxtbits; // 10
/* Were ready to start filling in the OFDM structure now */ /* Were ready to start filling in the OFDM structure now */
ofdm = new OFDM();
if ((ofdm = (struct OFDM *) malloc(sizeof (struct OFDM))) == NULL) { ofdm->pilot_samples = new std::complex<float>[ofdm_m + ofdm_ncp];
return NULL; ofdm->rxbuf = new std::complex<float>[ofdm_rxbuf];
} ofdm->pilots = new std::complex<float>[ofdm_nc + 2];
ofdm->pilot_samples = (std::complex<float>*) malloc(sizeof (std::complex<float>) * (ofdm_m + ofdm_ncp));
ofdm->rxbuf = (std::complex<float>*) malloc(sizeof (std::complex<float>) * ofdm_rxbuf);
ofdm->pilots = (std::complex<float>*) malloc(sizeof (std::complex<float>) * (ofdm_nc + 2));
/* /*
* rx_sym is a 2D array of variable size * rx_sym is a 2D array of variable size
@ -237,14 +233,14 @@ struct OFDM *ofdm_create(const struct OFDM_CONFIG *config) {
* allocate rx_sym row storage. It is a pointer to a pointer * allocate rx_sym row storage. It is a pointer to a pointer
*/ */
ofdm->rx_sym = (std::complex<float>**) malloc(sizeof (std::complex<float>) * (ofdm_ns + 3)); ofdm->rx_sym = new std::complex<float>*[ofdm_ns + 3];
/* allocate rx_sym column storage */ /* allocate rx_sym column storage */
int free_last_rx_sym = 0; int free_last_rx_sym = 0;
for (i = 0; i < (ofdm_ns + 3); i++) for (i = 0; i < (ofdm_ns + 3); i++)
{ {
ofdm->rx_sym[i] = (std::complex<float> *) malloc(sizeof(std::complex<float>) * (ofdm_nc + 2)); ofdm->rx_sym[i] = new std::complex<float>[ofdm_nc + 2];
if (ofdm->rx_sym[i] == NULL) { if (ofdm->rx_sym[i] == NULL) {
free_last_rx_sym = i; free_last_rx_sym = i;
@ -255,7 +251,7 @@ struct OFDM *ofdm_create(const struct OFDM_CONFIG *config) {
/* The rest of these are 1D arrays of variable size */ /* The rest of these are 1D arrays of variable size */
ofdm->rx_np = (std::complex<float>*) malloc(sizeof (std::complex<float>) * (ofdm_rowsperframe * ofdm_nc)); ofdm->rx_np = new std::complex<float>[ofdm_rowsperframe * ofdm_nc];
ofdm->rx_amp = (float*) malloc(sizeof (float) * (ofdm_rowsperframe * ofdm_nc)); ofdm->rx_amp = (float*) malloc(sizeof (float) * (ofdm_rowsperframe * ofdm_nc));
ofdm->aphase_est_pilot_log = (float*) malloc(sizeof (float) * (ofdm_rowsperframe * ofdm_nc)); ofdm->aphase_est_pilot_log = (float*) malloc(sizeof (float) * (ofdm_rowsperframe * ofdm_nc));
ofdm->tx_uw = (uint8_t*) malloc(sizeof (uint8_t) * ofdm_nuwbits); ofdm->tx_uw = (uint8_t*) malloc(sizeof (uint8_t) * ofdm_nuwbits);
@ -346,7 +342,7 @@ struct OFDM *ofdm_create(const struct OFDM_CONFIG *config) {
uw_ind[j + 1] = (val * 2) + 1; // bit index 2 uw_ind[j + 1] = (val * 2) + 1; // bit index 2
} }
tx_uw_syms = (std::complex<float>*) malloc(sizeof (std::complex<float>) * (ofdm_nuwbits / 2)); tx_uw_syms = new std::complex<float>[ofdm_nuwbits / 2];
for (i = 0; i < (ofdm_nuwbits / 2); i++) { for (i = 0; i < (ofdm_nuwbits / 2); i++) {
tx_uw_syms[i] = 1.0f; // qpsk_mod(0:0) tx_uw_syms[i] = 1.0f; // qpsk_mod(0:0)
@ -369,7 +365,7 @@ struct OFDM *ofdm_create(const struct OFDM_CONFIG *config) {
/* create the OFDM waveform */ /* create the OFDM waveform */
std::complex<float> *temp = (std::complex<float>*) malloc(sizeof (std::complex<float>) * ofdm_m); std::complex<float> *temp = new std::complex<float>[ofdm_m];
idft(ofdm, temp, ofdm->pilots); idft(ofdm, temp, ofdm->pilots);
@ -390,7 +386,8 @@ struct OFDM *ofdm_create(const struct OFDM_CONFIG *config) {
for (i = ofdm_ncp, j = 0; j < ofdm_m; i++, j++) { for (i = ofdm_ncp, j = 0; j < ofdm_m; i++, j++) {
ofdm->pilot_samples[i] = temp[j]; ofdm->pilot_samples[i] = temp[j];
} }
free(temp);
delete[] temp;
/* calculate constant used to normalise timing correlation maximum */ /* calculate constant used to normalise timing correlation maximum */
@ -409,25 +406,25 @@ struct OFDM *ofdm_create(const struct OFDM_CONFIG *config) {
//// Error return points with free call in the reverse order of allocation: //// Error return points with free call in the reverse order of allocation:
free(tx_uw_syms); delete[] tx_uw_syms;
free(uw_ind); free(uw_ind);
free(uw_ind_sym); free(uw_ind_sym);
free(ofdm->tx_uw); free(ofdm->tx_uw);
free(ofdm->aphase_est_pilot_log); free(ofdm->aphase_est_pilot_log);
free(ofdm->rx_amp); free(ofdm->rx_amp);
free(ofdm->rx_np); delete[] ofdm->rx_np;
for (i = 0; i < free_last_rx_sym; i++) { for (i = 0; i < free_last_rx_sym; i++) {
free(ofdm->rx_sym[i]); delete[] ofdm->rx_sym[i];
} }
free(ofdm->rx_sym); delete[] ofdm->rx_sym;
free(ofdm->pilots); delete[] ofdm->pilots;
free(ofdm->rxbuf); delete[] ofdm->rxbuf;
free(ofdm->pilot_samples); delete[] ofdm->pilot_samples;
free(ofdm); delete ofdm;
return(NULL); return(nullptr);
} }
void allocate_tx_bpf(struct OFDM *ofdm) { void allocate_tx_bpf(struct OFDM *ofdm) {
@ -451,16 +448,16 @@ void ofdm_destroy(struct OFDM *ofdm) {
if (ofdm->ofdm_tx_bpf) if (ofdm->ofdm_tx_bpf)
deallocate_tx_bpf(ofdm); deallocate_tx_bpf(ofdm);
free(ofdm->pilot_samples); delete[] ofdm->pilot_samples;
free(ofdm->rxbuf); delete[] ofdm->rxbuf;
free(ofdm->pilots); delete[] ofdm->pilots;
for (i = 0; i < (ofdm_ns + 3); i++) { /* 2D array */ for (i = 0; i < (ofdm_ns + 3); i++) { /* 2D array */
free(ofdm->rx_sym[i]); delete[] ofdm->rx_sym[i];
} }
free(ofdm->rx_sym); delete[] ofdm->rx_sym;
free(ofdm->rx_np); delete[] ofdm->rx_np;
free(ofdm->rx_amp); free(ofdm->rx_amp);
free(ofdm->aphase_est_pilot_log); free(ofdm->aphase_est_pilot_log);
free(ofdm->tx_uw); free(ofdm->tx_uw);