static void sparse_vq_pred_error(struct PEXP *pexp,
MODEL *model
)
{
int i, index;
float pred, error, error_q_angle, best_Wo;
COMP sparse_pe_in[MAX_AMP], sparse_pe_out[MAX_AMP];
float weights[MAX_AMP];
COMP error_q_rect;
best_Wo = refine_Wo(pexp, model, 1, model->L);
//best_Wo = (model->Wo + pexp->Wo_prev)/2.0;
/* transform to sparse pred error vector */
for(i=0; i<MAX_AMP; i++) {
sparse_pe_in[i].real = 0.0;
sparse_pe_in[i].imag = 0.0;
sparse_pe_out[i].real = 0.0;
sparse_pe_out[i].imag = 0.0;
}
//printf("\n");
for(i=1; i<=model->L; i++) {
pred = pexp->phi_prev[i] + N*i*best_Wo;
error = pred - model->phi[i];
index = MAX_AMP*i*model->Wo/PI;
assert(index < MAX_AMP);
sparse_pe_in[index].real = cos(error);
sparse_pe_in[index].imag = sin(error);
sparse_pe_out[index] = sparse_pe_in[index];
weights[index] = model->A[i];
//printf("%d ", index);
}
/* vector quantise */
split_vq(sparse_pe_out, pexp, pexp->vq1, weights, sparse_pe_in);
split_vq(sparse_pe_out, pexp, pexp->vq2, weights, sparse_pe_in);
split_vq(sparse_pe_out, pexp, pexp->vq3, weights, sparse_pe_in);
split_vq(sparse_pe_out, pexp, pexp->vq4, weights, sparse_pe_in);
split_vq(sparse_pe_out, pexp, pexp->vq5, weights, sparse_pe_in);
/* transform quantised phases back */
for(i=1; i<=model->L; i++) {
pred = pexp->phi_prev[i] + N*i*best_Wo;
index = MAX_AMP*i*model->Wo/PI;
assert(index < MAX_AMP);
error_q_rect = sparse_pe_out[index];
error_q_angle = atan2(error_q_rect.imag, error_q_rect.real);
model->phi[i] = pred - error_q_angle;
model->phi[i] = atan2(sin(model->phi[i]), cos(model->phi[i]));
}
}
void smooth_samples(struct AEXP *aexp, MODEL *model, int mode)
{
int m, i, j, index, step, nav, v, en;
float sparse_pe_in[MAX_AMP], av, amp_dB;
float sparse_pe_out[MAX_AMP];
float smoothed[MAX_AMP], smoothed_out[MAX_AMP];
float weights[MAX_AMP];
float enormdB;
frame_energy(model, &enormdB);
for(m=0; m<MAX_AMP; m++) {
sparse_pe_in[m] = 0.0;
sparse_pe_out[m] = 0.0;
}
/* set up sparse array */
for(m=1; m<=model->L; m++) {
assert(model->A[m] > 0.0);
index = MAX_AMP*m*model->Wo/PI;
assert(index < MAX_AMP);
sparse_pe_out[index] = sparse_pe_in[index] = 20.0*log10(model->A[m]) - enormdB;
}
/* now combine samples at high frequencies to reduce dimension */
step=4;
for(i=MAX_AMP/2,v=0; i<MAX_AMP; i+=step,v++) {
/* average over one band */
av = 0.0; nav = 0;
en = i+step;
if (en > (MAX_AMP-1))
en = MAX_AMP-1;
for(j=i; j<en; j++) {
if (sparse_pe_in[j] != 0.0) {
av += sparse_pe_in[j];
nav++;
}
}
if (nav) {
av /= nav;
smoothed[v] = av;
weights[v] = pow(10.0,av/20.0);
//weights[v] = 1.0;
}
else
smoothed[v] = 0.0;
}
if (mode == 1) {
for(i=0; i<v; i++)
printf("%5.2f ", smoothed[i]);
printf("\n");
}
if (mode == 2) {
for(i=0; i<v; i++)
smoothed_out[i] = 0;
split_vq(smoothed_out, aexp, aexp->vq1, weights, smoothed);
for(i=0; i<v; i++)
smoothed[i] = smoothed_out[i];
}
/* set all samples to smoothed average */
step = 4;
for(i=MAX_AMP/2,v=0; i<MAX_AMP; i+=step,v++) {
en = i+step;
if (en > (MAX_AMP-1))
en = MAX_AMP-1;
for(j=i; j<en; j++)
sparse_pe_out[j] = smoothed[v];
}
/* convert back to Am */
for(m=1; m<=model->L; m++) {
index = MAX_AMP*m*model->Wo/PI;
assert(index < MAX_AMP);
amp_dB = sparse_pe_out[index] + enormdB;
//printf("%d %4.2f %4.2f\n", m, 10.0*log10(model->A[m]), amp_dB);
model->A[m] = pow(10.0, amp_dB/20.0);
}
}
static void sparse_vq_amp(struct AEXP *aexp, MODEL *model)
{
int m, index;
float error, amp_dB, enormdB;
float sparse_pe_in[MAX_AMP];
float sparse_pe_out[MAX_AMP];
float weights[MAX_AMP];
frame_energy(model, &enormdB);
aexp->mag[2] = enormdB;
for(m=0; m<MAX_AMP; m++) {
sparse_pe_in[m] = 0.0;
sparse_pe_out[m] = 0.0;
}
for(m=1; m<=model->L; m++) {
assert(model->A[m] > 0.0);
error = 20.0*log10(model->A[m]) - enormdB;
index = MAX_AMP*m*model->Wo/PI;
assert(index < MAX_AMP);
sparse_pe_in[index] = error;
weights[index] = pow(model->A[m],0.8);
}
/* vector quantise */
for(m=0; m<MAX_AMP; m++) {
sparse_pe_out[m] = sparse_pe_in[m];
}
for(m=0; m<80; m++)
sparse_pe_out[m] = 0;
#define SPLIT
#ifdef SPLIT
aexp->indexes[0][2] = split_vq(sparse_pe_out, aexp, aexp->vq1, weights, sparse_pe_in);
aexp->indexes[1][2] = split_vq(sparse_pe_out, aexp, aexp->vq2, weights, sparse_pe_in);
aexp->indexes[2][2] = split_vq(sparse_pe_out, aexp, aexp->vq3, weights, sparse_pe_in);
aexp->indexes[3][2] = split_vq(sparse_pe_out, aexp, aexp->vq4, weights, sparse_pe_in);
aexp->indexes[4][2] = split_vq(sparse_pe_out, aexp, aexp->vq5, weights, sparse_pe_in);
#endif
//#define MULTISTAGE
#ifdef MULTISTAGE
aexp->indexes[0][2] = split_vq(sparse_pe_out, aexp, aexp->vq1, weights, sparse_pe_in);
aexp->indexes[1][2] = split_vq(sparse_pe_out, aexp, aexp->vq2, weights, sparse_pe_in);
aexp->indexes[2][2] = split_vq(sparse_pe_out, aexp, aexp->vq3, weights, sparse_pe_in);
//aexp->indexes[3][2] = split_vq(sparse_pe_out, aexp, aexp->vq4, weights, sparse_pe_in);
#endif
for(m=0; m<MAX_AMP; m++) {
if (sparse_pe_in[m] != 0.0)
aexp->vq_var += pow(sparse_pe_out[m] - sparse_pe_in[m], 2.0);
}
/* transform quantised amps back */
for(m=1; m<=model->L; m++) {
index = MAX_AMP*m*model->Wo/PI;
assert(index < MAX_AMP);
amp_dB = sparse_pe_out[index] + enormdB;
model->A[m] = pow(10.0, amp_dB/20.0);
}
//exit(0);
}
static void sparse_vq_pred_error(struct AEXP *aexp,
MODEL *model
)
{
int m, index;
float error, amp_dB, edB, enormdB;
float sparse_pe_in[MAX_AMP];
float sparse_pe_out[MAX_AMP];
float weights[MAX_AMP];
edB = frame_energy(model, &enormdB);
for(m=0; m<MAX_AMP; m++) {
sparse_pe_in[m] = 0.0;
sparse_pe_out[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]);
index = MAX_AMP*m*model->Wo/PI;
assert(index < MAX_AMP);
sparse_pe_in[index] = error;
weights[index] = model->A[m];
}
/* vector quantise */
for(m=0; m<MAX_AMP; m++) {
sparse_pe_out[m] = sparse_pe_in[m];
}
//#define SIM_VQ
#ifndef SIM_VQ
split_vq(sparse_pe_out, aexp, aexp->vq1, weights, sparse_pe_in);
#else
for(m=aexp->vq->offset; m<aexp->vq->offset+aexp->vq->k; m++) {
if (sparse_pe_in[m] != 0.0) {
float error = 8*(1.0 - 2.0*rand()/RAND_MAX);
aexp->vq_var += error*error;
aexp->vq_var_n++;
sparse_pe_out[m] = sparse_pe_in[m] + error;
}
}
#endif
if (edB > -100.0)
for(m=0; m<MAX_AMP; m++) {
if (sparse_pe_in[m] != 0.0)
aexp->vq_var += pow(sparse_pe_out[m] - sparse_pe_in[m], 2.0);
}
/* transform quantised amps back */
for(m=1; m<=model->L; m++) {
index = MAX_AMP*m*model->Wo/PI;
assert(index < MAX_AMP);
amp_dB = PRED_COEFF*20.0*log10(aexp->A_prev[m]) - sparse_pe_out[index];
//printf("in: %f out: %f\n", sparse_pe_in[index], sparse_pe_out[index]);
//printf("amp_dB: %f A[m] (dB) %f\n", amp_dB, 20.0*log10(model->A[m]));
model->A[m] = pow(10.0, amp_dB/20.0);
}
//exit(0);
}
void smooth_phase(struct PEXP *pexp, MODEL *model, int mode)
{
int m, i, j, index, step, v, en, nav, st;
COMP sparse_pe_in[MAX_AMP], av;
COMP sparse_pe_out[MAX_AMP];
COMP smoothed[MAX_AMP];
float best_Wo, pred, err;
float weights[MAX_AMP];
float avw, smoothed_weights[MAX_AMP];
COMP smoothed_in[MAX_AMP], smoothed_out[MAX_AMP];
best_Wo = refine_Wo(pexp, model, 1, model->L);
for(m=0; m<MAX_AMP; m++) {
sparse_pe_in[m].real = sparse_pe_in[m].imag = 0.0;
sparse_pe_out[m].real = sparse_pe_out[m].imag = 0.0;
}
/* set up sparse array */
for(m=1; m<=model->L; m++) {
pred = pexp->phi_prev[m] + N*m*best_Wo;
err = model->phi[m] - pred;
err = atan2(sin(err),cos(err));
index = MAX_AMP*m*model->Wo/PI;
assert(index < MAX_AMP);
sparse_pe_in[index].real = model->A[m]*cos(err);
sparse_pe_in[index].imag = model->A[m]*sin(err);
sparse_pe_out[index] = sparse_pe_in[index];
weights[index] = model->A[m];
}
/* now combine samples at high frequencies to reduce dimension */
step = 2;
st = 0;
for(i=st,v=0; i<MAX_AMP; i+=step,v++) {
/* average over one band */
av.real = 0.0; av.imag = 0.0; avw = 0.0; nav = 0;
en = i+step;
if (en > (MAX_AMP-1))
en = MAX_AMP-1;
for(j=i; j<en; j++) {
if ((sparse_pe_in[j].real != 0.0) &&(sparse_pe_in[j].imag != 0.0) ) {
av = cadd(av, sparse_pe_in[j]);
avw += weights[j];
nav++;
}
}
if (nav) {
smoothed[v] = av;
smoothed_weights[v] = avw/nav;
}
else
smoothed[v].real = smoothed[v].imag = 0.0;
}
if (mode == 2) {
for(i=0; i<MAX_AMP; i++) {
smoothed_in[i] = smoothed[i];
smoothed_out[i] = smoothed_in[i];
}
split_vq(smoothed_out, pexp, pexp->vq1, smoothed_weights, smoothed_in);
for(i=0; i<MAX_AMP; i++)
smoothed[i] = smoothed_out[i];
}
/* set all samples to smoothed average */
for(i=st,v=0; i<MAX_AMP; i+=step,v++) {
en = i+step;
if (en > (MAX_AMP-1))
en = MAX_AMP-1;
for(j=i; j<en; j++)
sparse_pe_out[j] = smoothed[v];
if (mode == 1)
printf("%f ", atan2(smoothed[v].imag, smoothed[v].real));
}
if (mode == 1)
printf("\n");
/* convert back to Am */
for(m=1; m<=model->L; m++) {
index = MAX_AMP*m*model->Wo/PI;
assert(index < MAX_AMP);
pred = pexp->phi_prev[m] + N*m*best_Wo;
err = atan2(sparse_pe_out[index].imag, sparse_pe_out[index].real);
model->phi[m] = pred + err;
}
}
