# Set default C++ flags.
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -g -O2 -std=gnu11")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -g -O3 -std=gnu11")
+# set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-function")
+
set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS}")
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS}")
set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS}")
*/
-static void print_sparse_pred_error(struct AEXP *aexp, MODEL *model, float mag_thresh)
-{
- int m, index;
- float mag, error;
- float sparse_pe[MAX_AMP];
-
- mag = 0.0;
- for(m=1; m<=model->L; m++)
- mag += model->A[m]*model->A[m];
- mag = 10*log10(mag/model->L);
-
- if (mag > mag_thresh) {
- for(m=0; m<MAX_AMP; m++) {
- sparse_pe[m] = 0.0;
- }
-
- for(m=1; m<=model->L; m++) {
- assert(model->A[m] > 0.0);
- error = PRED_COEFF*20.0*log10(aexp->A_prev[m]) - 20.0*log10(model->A[m]);
- //error = 20.0*log10(model->A[m]) - mag;
-
- index = MAX_AMP*m*model->Wo/PI;
- assert(index < MAX_AMP);
- sparse_pe[index] = error;
- }
-
- /* dump sparse amp vector */
-
- for(m=0; m<MAX_AMP; m++)
- printf("%f ", sparse_pe[m]);
- printf("\n");
- }
-}
-
-
static float frame_energy(MODEL *model, float *enormdB) {
int m;
float e, edB;
return vq_ind;
}
+#if 0
+static void print_sparse_pred_error(struct AEXP *aexp, MODEL *model, float mag_thresh)
+{
+ int m, index;
+ float mag, error;
+ float sparse_pe[MAX_AMP];
+
+ mag = 0.0;
+ for(m=1; m<=model->L; m++)
+ mag += model->A[m]*model->A[m];
+ mag = 10*log10(mag/model->L);
+
+ if (mag > mag_thresh) {
+ for(m=0; m<MAX_AMP; m++) {
+ sparse_pe[m] = 0.0;
+ }
+
+ for(m=1; m<=model->L; m++) {
+ assert(model->A[m] > 0.0);
+ error = PRED_COEFF*20.0*log10(aexp->A_prev[m]) - 20.0*log10(model->A[m]);
+ //error = 20.0*log10(model->A[m]) - mag;
+
+ index = MAX_AMP*m*model->Wo/PI;
+ assert(index < MAX_AMP);
+ sparse_pe[index] = error;
+ }
+
+ /* dump sparse amp vector */
+
+ for(m=0; m<MAX_AMP; m++)
+ printf("%f ", sparse_pe[m]);
+ printf("\n");
+ }
+}
+
static void sparse_vq_pred_error(struct AEXP *aexp,
MODEL *model
}
}
-
+#endif
static void sparse_vq_amp(struct AEXP *aexp, MODEL *model)
{
int m, index;
int state, next_state;
float ber, r, burst_length, burst_period, burst_timer, ber_est;
unsigned char mask;
- int natural, dump, softdec, bit, ret;
+ int natural, softdec, bit, ret;
+#ifdef DUMP
+ int dump;
+#endif
int report_energy;
char* opt_string = "h:";
ber = 0.0;
burst_length = burst_period = 0.0;
burst_timer = 0.0;
- dump = natural = softdec = 0;
+ natural = softdec = 0;
report_energy = 0;
+#ifdef DUMP
+ dump = 0;
+#endif
codec2 = codec2_create(mode);
nsam = codec2_samples_per_frame(codec2);
FILE *fin; /* input speech file */
short buf[N_SAMP]; /* input/output buffer */
float buf_float[N_SAMP];
- float buf_float_bpf[N_SAMP];
float Sn[M_PITCH]; /* float input speech samples */
float Sn_pre[M_PITCH]; /* pre-emphasised input speech samples */
COMP Sw[FFT_ENC]; /* DFT of Sn[] */
int prede = 0;
float pre_mem = 0.0, de_mem = 0.0;
float ak[order];
- COMP Sw_[FFT_ENC];
- COMP Ew[FFT_ENC];
+ // COMP Sw_[FFT_ENC];
+ // COMP Ew[FFT_ENC];
int phase0 = 0;
float ex_phase[MAX_AMP+1];
of each entry, used for reading in phases generated by Octave */
if (awread) {
- int j;
int ret = fread(Aw, sizeof(COMP), FFT_ENC, faw);
- //for(j=0; j<10; j++) {
+ //for(int j=0; j<10; j++) {
// fprintf(stderr, "%f %f\n", Aw[j].real, Aw[j].imag);
//}
//exit(0);
#include "_kiss_fft_guts.h"
#else
+#if 0
+// caching constants in RAM did not seem to have an effect on performance
+// TODO: Decide what to with this code
#define FFT_INIT_CACHE_SIZE 4
const arm_cfft_instance_f32* fft_init_cache[FFT_INIT_CACHE_SIZE];
return retval;
}
#endif
+#endif
void codec2_fft_free(codec2_fft_cfg cfg)
{
int bits_per_codec_frame;
int bytes_per_codec_frame;
int Nc;
+#ifdef CHANNEL_SIM
COMP foff_phase_rect;
float foff;
+#endif
if (argc < 3) {
printf("usage: %s InputBitFile OutputModemRawFile [Nc]\n", argv[0]);
tx_bits = (int*)malloc(sizeof(int)*bits_per_codec_frame);
assert(tx_bits != NULL);
+#ifdef CHANNEL_SIM
foff = -100;
foff_phase_rect.real = 1.0; foff_phase_rect.imag = 0.0;
+#endif
frames = 0;
struct FM *fm;
short buf[N*2];
float rx[N];
+#if defined(TEST_MODE) && !defined(TEST_MODE_COMP)
float rx_out[N];
+#endif
COMP out_comp[N];
int i;
int i;
int match[2];
int r;
-
+
+ /* defaults to make compiler happy on -O3 */
+
+ *pt = FRAME_PAYLOAD_TYPE_VOICE;
+ *rdiff = 0;
+
/* Set up parameters for the standard type of frame */
if(frame_type == FREEDV_VHF_FRAME_A){
uw[0] = A_uw_v;
match[i] = diff[i] <= tol;
}
/* Pick the best matching UW */
+
if (diff[0] < diff[1]) {
r = match[0];
*rdiff = diff[0];
if (digits[i]== cols) {
digits[i] = 0;
digits[i+1]++;
+ printf("i = %d\n", i);
}
} while (digits[rows-1] != cols);
\*---------------------------------------------------------------------------*/
-/* Bubblesort to find highest amplitude harmonics */
-
-struct AMPINDEX {
- float amp;
- int index;
-};
-
-static void bubbleSort(struct AMPINDEX numbers[], int array_size)
-{
- int i, j;
- struct AMPINDEX temp;
-
- for (i = (array_size - 1); i > 0; i--)
- {
- for (j = 1; j <= i; j++)
- {
- //printf("i %d j %d %f %f \n", i, j, numbers[j-1].amp, numbers[j].amp);
- if (numbers[j-1].amp < numbers[j].amp)
- {
- temp = numbers[j-1];
- numbers[j-1] = numbers[j];
- numbers[j] = temp;
- }
- }
- }
-}
-
-
-static void print_pred_error(struct PEXP *pexp, MODEL *model, int start, int end, float mag_thresh) {
- int i;
- float mag;
-
- mag = 0.0;
- for(i=start; i<=end; i++)
- mag += model->A[i]*model->A[i];
- mag = 10*log10(mag/(end-start));
-
- if (mag > mag_thresh) {
- for(i=start; i<=end; i++) {
- float pred = pexp->phi_prev[i] + N_SAMP*i*(model->Wo + pexp->Wo_prev)/2.0;
- float err = pred - model->phi[i];
- err = atan2(sin(err),cos(err));
- printf("%f\n",err);
- }
- //printf("\n");
- }
-
-}
-
static void predict_phases(struct PEXP *pexp, MODEL *model, int start, int end) {
int i;
}
-static void rand_phases(MODEL *model, int start, int end) {
- int i;
-
- for(i=start; i<=end; i++)
- model->phi[i] = PI*(1.0 - 2.0*(float)rand()/RAND_MAX);
-
-}
-
static void quant_phase(float *phase, float min, float max, int bits) {
int levels = 1 << bits;
int index;
}
}
+#if 0
+/* Bubblesort to find highest amplitude harmonics */
+
+struct AMPINDEX {
+ float amp;
+ int index;
+};
+
+static void bubbleSort(struct AMPINDEX numbers[], int array_size)
+{
+ int i, j;
+ struct AMPINDEX temp;
+
+ for (i = (array_size - 1); i > 0; i--)
+ {
+ for (j = 1; j <= i; j++)
+ {
+ //printf("i %d j %d %f %f \n", i, j, numbers[j-1].amp, numbers[j].amp);
+ if (numbers[j-1].amp < numbers[j].amp)
+ {
+ temp = numbers[j-1];
+ numbers[j-1] = numbers[j];
+ numbers[j] = temp;
+ }
+ }
+ }
+}
+
+static void print_pred_error(struct PEXP *pexp, MODEL *model, int start, int end, float mag_thresh) {
+ int i;
+ float mag;
+
+ mag = 0.0;
+ for(i=start; i<=end; i++)
+ mag += model->A[i]*model->A[i];
+ mag = 10*log10(mag/(end-start));
+
+ if (mag > mag_thresh) {
+ for(i=start; i<=end; i++) {
+ float pred = pexp->phi_prev[i] + N_SAMP*i*(model->Wo + pexp->Wo_prev)/2.0;
+ float err = pred - model->phi[i];
+ err = atan2(sin(err),cos(err));
+ printf("%f\n",err);
+ }
+ //printf("\n");
+ }
+
+}
+
+
+static void rand_phases(MODEL *model, int start, int end) {
+ int i;
+
+ for(i=start; i<=end; i++)
+ model->phi[i] = PI*(1.0 - 2.0*(float)rand()/RAND_MAX);
+
+}
+
static void fixed_bits_per_frame(struct PEXP *pexp, MODEL *model, int m, int budget) {
int res, finished;
}
}
-
static void print_sparse_pred_error(struct PEXP *pexp, MODEL *model, int start, int end, float mag_thresh)
{
int i, index;
}
}
+static void predict_phases1(struct PEXP *pexp, MODEL *model, int start, int end) {
+ int i;
+ float best_Wo;
+
+ best_Wo = refine_Wo(pexp, model, 1, model->L);
+
+ for(i=start; i<=end; i++) {
+ model->phi[i] = pexp->phi_prev[i] + N_SAMP*i*best_Wo;
+ }
+}
+
+
+#endif
static void update_snr_calc(struct PEXP *pexp, MODEL *model, float before[])
{
}
-static void predict_phases1(struct PEXP *pexp, MODEL *model, int start, int end) {
- int i;
- float best_Wo;
-
- best_Wo = refine_Wo(pexp, model, 1, model->L);
-
- for(i=start; i<=end; i++) {
- model->phi[i] = pexp->phi_prev[i] + N_SAMP*i*best_Wo;
- }
-}
-
-
/*
This functions tests theory that some bands can be combined together
due to less frequency resolution at higher frequencies. This will
void cb_phase2(struct PEXP *pexp, MODEL *model) {
int st, m, i, a, b, step;
- float diff,w,c,s,phi1_;
+ float diff,w,c,s;
float A[MAX_AMP];
for(m=1; m<=model->L; m++) {
w = 1.0;
c += w*cos(diff); s += w*sin(diff);
}
- phi1_ = atan2(s,c);
+ // float phi1_ = atan2(s,c);
printf("replacing: ");
for(i=a; i<b; i++) {
//model->phi[i] = i*phi1_;
#include "machdep.h"
#define LSP_DELTA1 0.01 /* grid spacing for LSP root searches */
+// #define MBEST_PRINT_OUT
+#ifdef MBEST_PRINT_OUT
+ #define MBEST_PRINT(a,b) mbest_print((a),(b))
+#else
+ #define MBEST_PRINT(a,b)
+#endif
/*---------------------------------------------------------------------------*\
}
+#ifdef MBEST_PRINT_OUT
static void mbest_print(char title[], struct MBEST *mbest) {
int i,j;
fprintf(stderr, " %f\n", mbest->list[i].error);
}
}
+#endif
/*---------------------------------------------------------------------------*\
/* Stage 1 */
mbest_search(codebook1, x, w, ndim, lspmelvq_cb[0].m, mbest_stage1, index);
- //mbest_print("Stage 1:", mbest_stage1);
+ MBEST_PRINT("Stage 1:", mbest_stage1);
+
/* Stage 2 */
target[i] = x[i] - codebook1[ndim*n1+i];
mbest_search(codebook2, target, w, ndim, lspmelvq_cb[1].m, mbest_stage2, index);
}
- //mbest_print("Stage 2:", mbest_stage2);
+ MBEST_PRINT("Stage 2:", mbest_stage2);
/* Stage 3 */
target[i] = x[i] - codebook1[ndim*n1+i] - codebook2[ndim*n2+i];
mbest_search(codebook3, target, w, ndim, lspmelvq_cb[2].m, mbest_stage3, index);
}
- //mbest_print("Stage 3:", mbest_stage3);
+ MBEST_PRINT("Stage 3:", mbest_stage3);
n1 = mbest_stage3->list[0].index[2];
n2 = mbest_stage3->list[0].index[1];
int main(void) {
FILE *f=fopen("testamp.flt", "wb");
- int i, j, m, L, index;
+ int i, m, L, index;
float amp, noisey_amp, pitch, Wo;
float sparse_pe[MAX_AMP];
*/
for(i=0; i<E; i++) {
amp = i+1;
- for(j=0; j<D; j++)
+ for(int j=0; j<D; j++)
fwrite(&, sizeof(float), 1, f);
}
#endif
FILE *f=fopen("testph.flt", "wb");
int i, m, L, index;
float angle, noisey_angle, pitch, Wo;
- COMP c;
COMP sparse_pe[MAX_AMP];
#ifdef TEST1
+ COMP c;
for(i=0; i<D*E; i++) {
c.real = cos(i*TWO_PI/(M*D));
c.imag = sin(i*TWO_PI/(M*D));
int main(int argc, char *argv[]) {
FILE *fraw, *fheader;
- int i, samples, ret;
+ int i, samples;
short sam;
if (argc != 5) {
fprintf(fheader, "short %s[] = {\n", argv[3]);
for(i=0; i<samples-1; i++) {
- ret = fread(&sam, sizeof(short), 1, fraw);
+ fread(&sam, sizeof(short), 1, fraw);
fprintf(fheader, "%d,\n", sam);
}
- ret = fread(&sam, sizeof(short), 1, fraw);
+ fread(&sam, sizeof(short), 1, fraw);
fprintf(fheader, "%d\n};\n", sam);
fclose(fraw);
float lsp_hz[LPC_ORD]; /* LSP input vector in Hz */
int vectors; /* number LSP vectors processed */
int k,m; /* LSP vector order and codebook size */
- int index;
float wt[1]; /* weighting (not used here for scalars) */
const float *cb; /* LSP quantiser codebook */
- int i, ret;
+ int i;
float total_se;
if (argc < 2) {
/* Read LSP input vector speech */
for (i=0; i<LPC_ORD; i++) {
- ret = fscanf(ftrain, "%f ", &lsp[i]);
+ fscanf(ftrain, "%f ", &lsp[i]);
}
vectors++;
if ((vectors % 1000) == 0)
k = lsp_cb[i].k;
m = lsp_cb[i].m;
cb = lsp_cb[i].cb;
- index = quantise(cb, &lsp_hz[i], wt, k, m, &total_se);
- //printf("k %d m %d lsp[%d] %f %f se %f\n", k,m,i,lsp_hz[i], cb[index],se);
+ #if 1
+ quantise(cb, &lsp_hz[i], wt, k, m, &total_se);
+ #else
+ int index = quantise(cb, &lsp_hz[i], wt, k, m, &total_se);
+ printf("k %d m %d lsp[%d] %f %f se %f\n", k,m,i,lsp_hz[i], cb[index],se);
+ #endif
}
//printf("total se %f\n", total_se);
//exit(0);
float *weight, *weight2, *weight3;
float *delta, *delta2;
float tmp, err, min_dist, total_min_dist;
- int ret;
char filename[256];
FILE *fcb;
break;
for (j=0;j<ndim;j++)
{
- ret = fscanf(ftrain, "%f ", &tmp);
+ fscanf(ftrain, "%f ", &tmp);
}
nb_vectors++;
if ((nb_vectors % 1000) == 0)
break;
for (j=0;j<ndim;j++)
{
- ret = fscanf(ftrain, "%f ", &data[i*ndim+j]);
+ fscanf(ftrain, "%f ", &data[i*ndim+j]);
}
}
nb_vectors = i;
float delta; /* improvement in distortion */
FILE *ftrain; /* file containing training set */
FILE *fvq; /* file containing vector quantiser */
- int ret;
/* Interpret command line arguments */
/* set up initial codebook state from samples of training set */
rewind(ftrain);
- ret = fread(cb, sizeof(float), k*m, ftrain);
+ fread(cb, sizeof(float), k*m, ftrain);
/* main loop */
se = 0.0;
rewind(ftrain);
for(i=0; i<J; i++) {
- ret = fread(vec, sizeof(float), k, ftrain);
+ fread(vec, sizeof(float), k, ftrain);
ind = quantise(cb, vec, k, m, &se);
n[ind]++;
acc(¢[ind*k], vec, k);
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 b; /* equivalent number of bits */
- float improvement;
- float sd_vec, sd_element, sd_theory, bits_theory;
+ float sd_vec;
int var_n;
/* Interpret command line arguments */
/* set up initial codebook state from samples of training set */
rewind(ftrain);
- ret = fread(cb, sizeof(COMP), d*e, ftrain);
+ fread(cb, sizeof(COMP), d*e, ftrain);
/* codebook can't have any zero phase angle entries, these need to be set to
zero angle so cmult used to find phase angle differences works */
printf("Iteration delta var std dev\n");
printf("--------------------------------\n");
- b = log10((float)e)/log10(2.0);
- sd_theory = (PI/sqrt(3.0))*pow(2.0, -b/(float)d);
+ // float b = log10((float)e)/log10(2.0);
+ // float sd_theory = (PI/sqrt(3.0))*pow(2.0, -b/(float)d);
iterations = 0;
finished = 0;
se = 0.0;
rewind(ftrain);
for(i=0; i<J; i++) {
- ret = fread(vec, sizeof(COMP), d, ftrain);
+ fread(vec, sizeof(COMP), d, ftrain);
ind = quantise(cb, vec, d, e, &se);
//printf("%d ", ind);
n[ind]++;
/* we need to know dimension of cb (which varies from vector to vector)
to calc bits_theory. Maybe measure and use average dimension....
*/
- //bits_theory = d*log10(PI/(sd_element*sqrt(3.0)))/log10(2.0);
- //improvement = bits_theory - b;
+ //float sd_element;
+ //float bits_theory = d*log10(PI/(sd_element*sqrt(3.0)))/log10(2.0);
+ //float improvement = bits_theory - b;
//print_vec(cent, d, 1);
projects / freetel-svn-tracking.git / commitdiff