/* find bin */
+ b = MAX_BINS;
for(i=0; i<nbins; i++)
if ((f > bins[i]) && (f <= bins[i+1]))
b = i;
/* find bin */
+ b = MAX_BINS;
for(i=0; i<nbins; i++)
if ((f > bins[i]) && (f <= bins[i+1]))
b = i;
#include "bpf.h"
#include "bpfb.h"
-void synth_one_frame(kiss_fft_cfg fft_inv_cfg, short buf[], MODEL *model, float Sn_[], float Pn[], int prede, float *de_mem, float gain);
+void synth_one_frame(codec2_fftr_cfg fftr_inv_cfg, short buf[], MODEL *model, float Sn_[], float Pn[], int prede, float *de_mem, float gain);
void print_help(const struct option *long_options, int num_opts, char* argv[]);
float buf_float[N_SAMP];
float buf_float_bpf[N_SAMP];
float Sn[M_PITCH]; /* float input speech samples */
- float Sn_pre[N_SAMP]; /* pre-emphasised input speech samples */
+ float Sn_pre[M_PITCH]; /* pre-emphasised input speech samples */
COMP Sw[FFT_ENC]; /* DFT of Sn[] */
codec2_fft_cfg fft_fwd_cfg;
- codec2_fft_cfg fft_inv_cfg;
+ codec2_fftr_cfg fftr_fwd_cfg;
+ codec2_fftr_cfg fftr_inv_cfg;
float w[M_PITCH]; /* time domain hamming window */
COMP W[FFT_ENC]; /* DFT of w[] */
MODEL model;
float bpf_buf[BPF_N+N_SAMP];
float lspmelvq_mse = 0.0;
int amread, Woread;
- FILE *fam, *fWo;
+ FILE *fam = NULL, *fWo = NULL;
int awread;
- FILE *faw;
+ FILE *faw = NULL;
char* opt_string = "ho:";
struct option long_options[] = {
/* Initialise ------------------------------------------------------------*/
fft_fwd_cfg = codec2_fft_alloc(FFT_ENC, 0, NULL, NULL); /* fwd FFT,used in several places */
- fft_inv_cfg = codec2_fft_alloc(FFT_DEC, 1, NULL, NULL); /* inverse FFT, used just for synth */
+ fftr_fwd_cfg = codec2_fftr_alloc(FFT_ENC, 0, NULL, NULL); /* fwd FFT,used in several places */
+ fftr_inv_cfg = codec2_fftr_alloc(FFT_DEC, 1, NULL, NULL); /* inverse FFT, used just for synth */
make_analysis_window(fft_fwd_cfg, w, W);
make_synthesis_window(Pn);
quantise_init();
for(i=0; i<=order; i++)
a[i].real = ak[i];
- kiss_fft(fft_fwd_cfg, (kiss_fft_cpx *)a, (kiss_fft_cpx *)Aw);
+ codec2_fft(fft_fwd_cfg, a, Aw);
if (hand_voicing) {
fscanf(fvoicing,"%d\n",&model.voiced);
for(i=0; i<decimate; i++) {
if (lpc_model) {
lsp_to_lpc(&lsps_dec[i][0], &ak_dec[i][0], order);
- aks_to_M2(fft_fwd_cfg, &ak_dec[i][0], order, &model_dec[i], e_dec[i],
+ aks_to_M2(fftr_fwd_cfg, &ak_dec[i][0], order, &model_dec[i], e_dec[i],
&snr, 0, simlpcpf, lpcpf, 1, LPCPF_BETA, LPCPF_GAMMA, Aw);
apply_lpc_correction(&model_dec[i]);
sum_snr += snr;
phase_synth_zero_order(fft_fwd_cfg, &model_dec[i], ex_phase, Aw);
if (postfilt)
postfilter(&model_dec[i], &bg_est);
- synth_one_frame(fft_inv_cfg, buf, &model_dec[i], Sn_, Pn, prede, &de_mem, gain);
+ synth_one_frame(fftr_inv_cfg, buf, &model_dec[i], Sn_, Pn, prede, &de_mem, gain);
if (fout != NULL) fwrite(buf,sizeof(short),N_SAMP,fout);
}
return 0;
}
-void synth_one_frame(kiss_fft_cfg fft_inv_cfg, short buf[], MODEL *model, float Sn_[],
+void synth_one_frame(codec2_fftr_cfg fftr_inv_cfg, short buf[], MODEL *model, float Sn_[],
float Pn[], int prede, float *de_mem, float gain)
{
int i;
- synthesise(fft_inv_cfg, Sn_, model, Pn, 1);
+ synthesise(fftr_inv_cfg, Sn_, model, Pn, 1);
if (prede)
de_emp(Sn_, Sn_, de_mem, N_SAMP);
void codec2_set_natural_or_gray(struct CODEC2 *codec2_state, int gray);\r
void codec2_set_softdec(struct CODEC2 *c2, float *softdec);\r
float codec2_get_energy(struct CODEC2 *codec2_state, const unsigned char *bits);\r
+
\r
#endif\r
\r
float *softdec; /* optional soft decn bits from demod */
};
+// test and debug
+void analyse_one_frame(struct CODEC2 *c2, MODEL *model, short speech[]);
+void synthesise_one_frame(struct CODEC2 *c2, short speech[], MODEL *model,
+ COMP Aw[]);
#endif
float No, variance;
COMP scaled_noise;
float hf_gain;
- COMP *ch_fdm_delay, aspread, aspread_2ms, delayed, direct;
+ COMP *ch_fdm_delay = NULL, aspread, aspread_2ms, delayed, direct;
float tx_pwr, tx_pwr_fade, noise_pwr;
int frames, i, j, k, ret, clipped;
float sam, peak, inclip, papr, CNo, snr3k, EbNo700;
/* init HF fading model */
+ ffading = NULL;
+ nhfdelay = 0;
if (fading_en) {
if (fading_en == 1) {
ffading = fopen(FAST_FADING_FILE_NAME, "rb");
/* --------------------------------------------------------*\
Main Loop
\*---------------------------------------------------------*/
-
+ frames = 0;
while(fread(buf, sizeof(short), BUF_N, fin) == BUF_N) {
frames++;
COMP rx_fdm[COHPSK_MAX_SAMPLES_PER_FRAME];
short rx_fdm_scaled[COHPSK_MAX_SAMPLES_PER_FRAME];
int frames, sync, nin_frame;
- float *rx_amp_log;
- float *rx_phi_log;
- COMP *rx_symb_log;
+ float *rx_amp_log = NULL;
+ float *rx_phi_log = NULL;
+ COMP *rx_symb_log = NULL;
float f_est_log[LOG_FRAMES], ratio_log[LOG_FRAMES];
int i, r, c, log_data_r, oct, logframes;
#include <errno.h>
#include "codec2_fdmdv.h"
+#include "fdmdv_internal.h"
int main(int argc, char *argv[])
{
/* real signal so we adjust SNR to suit. I think. I always get confused by this! */
- fdmdv_simulate_channel(fdmdv, rx_fdm, FDMDV_NOM_SAMPLES_PER_FRAME, snrdB - 3.0);
+ fdmdv_simulate_channel(&fdmdv->sig_pwr_av, rx_fdm, FDMDV_NOM_SAMPLES_PER_FRAME, snrdB - 3.0);
for(i=0; i<FDMDV_NOM_SAMPLES_PER_FRAME; i++) {
sam = FDMDV_SCALE*rx_fdm[i].real;
int data_flag_index, n_ascii, nspare;
short abit[1];
char ascii_out;
- float rx_bits[COHPSK_BITS_PER_FRAME];
+ char rx_bits[COHPSK_BITS_PER_FRAME];
int sync;
int frames;
for(i=0; i<f->nin; i++)
demod_in[i] = fcmult(1.0/FDMDV_SCALE, demod_in[i]);
- cohpsk_demod(f->cohpsk, rx_bits, &sync, demod_in, &f->nin);
+ cohpsk_demod(f->cohpsk, (float*)rx_bits, &sync, demod_in, &f->nin);
f->sync = sync;
cohpsk_get_demod_stats(f->cohpsk, &f->stats);
f->snr_est = f->stats.snr_est;
bitbuf = (uint8_t*)alloca(sizeof(uint8_t)*FSK_FRAME_SIZE);
/* Write out sync frame and sequence */
- for(i=0; i<FSK_FRAME_SIZE; i){
+ for(i=0; i<FSK_FRAME_SIZE; ){
bitbuf[i++] = rand()&0x1;
}
for(i=0;i<sizeof(init);i++){
}
-signed int printf_header(FILE* f, char* buffer,const size_t max_buf, size_t* buf_idx_ptr, const char *name, const char *dtype, int rows, int cols, int isFloat)
+void printf_header(FILE* f, char* buffer,const size_t max_buf, size_t* buf_idx_ptr, const char *name, const char *dtype, int rows, int cols, int isFloat)
{
#ifdef ARM_MATH_CM4
printf_buffer(f, buffer, OCTAVE_BUFSIZE, buf_idx_ptr, "# hex: %s\n", isFloat?"true":"false");
Wo_est = (model->Wo + pexp->Wo_prev)/2.0;
best_var = 1E32;
+ best_Wo = Wo_est;
for(Wo=0.97*Wo_est; Wo<=1.03*Wo_est; Wo+=0.001*Wo_est) {
/* predict phase and sum differences between harmonics */
/* find bin */
+ b = MAX_BINS;
for(i=0; i<nbins; i++)
if ((f > bins[i]) && (f <= bins[i+1]))
b = i;
/* find bin */
+ b = MAX_BINS;
for(i=0; i<nbins; i++)
if ((f > bins[i]) && (f <= bins[i+1]))
b = i;
/* find bin */
+ b = MAX_BINS;
for(i=0; i<nbins; i++)
if ((f > bins[i]) && (f <= bins[i+1]))
b = i;
/* find bin */
+ b = MAX_BINS;
for(i=0; i<nbins; i++)
if ((f > bins[i]) && (f <= bins[i+1]))
b = i;
#define CORRECT_OFFSET 10 /* LSPs start 10 bits int frame qt 2400 bit/s */
-static int check_candidate(char bits[], int offset)
+static int check_candidate(unsigned char bits[], int offset)
{
int i;
int lsp_indexes[LPC_ORD];
struct CODEC2 *c2;
int i,offset, nsamples, nbits, nbytes, frames;
short *speech;
- char *bits;
+ unsigned char *bits;
FILE *fin;
int swaps, pass, fail, match;
/* keep FRAMES frame memory of bit stream */
- bits = (char*)malloc(F*nbytes*sizeof(char));
+ bits = (unsigned char*)malloc(F*nbytes*sizeof(unsigned char));
for(i=0; i<F*nbytes; i++)
bits[i] = 0;
COMP ch_fdm[COHPSK_NOM_SAMPLES_PER_FRAME];
COMP ch_buf[CH_BUF_SZ];
float rx_bits_sd[COHPSK_BITS_PER_FRAME];
+ char rx_bits_char[COHPSK_BITS_PER_FRAME];
float *rx_amp_log;
float *rx_phi_log;
COMP *rx_symb_log;
nbits = 0;
/* init HF fading model */
+ ffading = NULL;
+ ch_fdm_delay = NULL;
if (fading_en) {
ffading = fopen(FADING_FILE_NAME, "rb");
memcpy(ch_buf, &ch_buf[nin_frame], sizeof(COMP)*ch_buf_n);
nin_frame = tmp;
- cohpsk_put_test_bits(coh, &state, error_pattern, &bit_errors, rx_bits_sd);
+
+ for (int i = 0; i < COHPSK_BITS_PER_FRAME; i++)
+ {
+ rx_bits_char[i] = rx_bits_sd[i];
+ }
+
+ cohpsk_put_test_bits(coh, &state, error_pattern, &bit_errors, rx_bits_char);
nerrors += bit_errors;
nbits += COHPSK_BITS_PER_FRAME;
#include "defines.h"
#include "comp.h"
#include "codec2.h"
+#include "lsp.h"
#include "quantise.h"
#include "interp.h"
#include "codec2_internal.h"
/* find bit we are corrupting */
found_bit = 0;
+ mask = 0;
+ index = -1;
for(i=0; i<LSP_SCALAR_INDEXES; i++) {
if (!found_bit) {
if (bit_to_corrupt > lsp_bits(i))
printf("Error in malloc.\n");
exit(1);
}
- printf("training array is %d bytes\n", sizeof(float)*k*J);
+ printf("training array is %lu bytes\n", sizeof(float)*k*J);
n = (int*)malloc(sizeof(int)*J);
if (n == NULL) {
float delta; /* improvement in distortion */
FILE *ftrain; /* file containing training set */
FILE *fvq; /* file containing vector quantiser */
- int ret;
int i,j, finished, iterations;
float sd;
int var_n, bits, b, levels;
printf("initial codebook...\n");
#endif
for(i=0; i<J; i++) {
- ret = fread(vec, sizeof(float), d, ftrain);
+ fread(vec, sizeof(float), d, ftrain);
#ifdef DBG
print_vec(vec, d, 1);
#endif
printf("bits Iteration delta var std dev\n");
printf("---------------------------------------\n");
+ levels = 0;
+
for(b=1; b<=bits; b++) {
levels = 1<<b;
iterations = 0;
se = 0.0;
rewind(ftrain);
for(i=0; i<J; i++) {
- ret = fread(vec, sizeof(float), d, ftrain);
+ fread(vec, sizeof(float), d, ftrain);
ind = quantise(cb, vec, d, levels, &se);
//ind = gain_shape_quantise(cb, vec, d, levels, &se, &best_gain);
//for(j=0; j<d; j++)
assert(ferr != NULL);
rewind(ftrain);
for(i=0; i<J; i++) {
- ret = fread(vec, sizeof(float), d, ftrain);
+ fread(vec, sizeof(float), d, ftrain);
ind = quantise(cb, vec, d, levels, &se);
for(j=0; j<d; j++) {
if (vec[j] != 0.0)