Nfft_phase = 128;
model_ = zeros(frames, max_amp+2);
voicing_ = zeros(1,frames);
- Hm = zeros(frames, max_amp);
- phi = zeros(1,max_amp);
+ H = zeros(frames, max_amp);
for f=1:M:frames
if voicing(f)
index = encode_log_Wo(model(f,1), 6);
phase = determine_phase(model_, k, Nfft_phase);
for m=1:model_(k,2)
b = round(m*model_(k,1)*Nfft_phase/(2*pi)); % map harmonic centre to DFT bin
- phi(m) = phase(b+1);
- Hm(k,m) = exp(-j*phi(m));
+ H(k,m) = exp(-j*phase(b+1));
end
end
%Hm(2,:) - Hm_c(2,:)
figure(1);
- mesh(angle(Hm));
+ mesh(angle(H));
figure(2);
- mesh(angle(Hm_c));
+ mesh(angle(H_c));
figure(3);
- mesh(abs(Hm - Hm_c));
+ mesh(abs(H - H_c));
check(rate_K_surface, rate_K_surface_c, 'rate_K_surface', 0.01);
check(mean_f, mean_c, 'mean', 0.01);
check(interpolated_surface_, interpolated_surface__c, 'interpolated_surface_', 0.01);
check(model_(:,1), model__c(:,1), 'interpolated Wo_', 0.001);
check(voicing_, voicing__c, 'interpolated voicing');
- check(model_(:,3:max_amp+2), model__c(:,3:max_amp+2), 'rate L surface at dec', 0.1);
- check(Hm, Hm_c, 'phase surface');
+ check(model_(:,3:max_amp+2), model__c(:,3:max_amp+2), 'rate L Am surface ', 0.1);
+ check(H, H_c, 'phase surface');
#{
\*---------------------------------------------------------------------------*/
-void interp_Wo_v(float Wo_[], int voicing_[], float Wo1, float Wo2, int voicing1, int voicing2)
+void interp_Wo_v(float Wo_[], int L_[], int voicing_[], float Wo1, float Wo2, int voicing1, int voicing2)
{
int i;
- int M = 4;
+ int M = 4; /* interpolation rate */
for(i=0; i<M; i++)
voicing_[i] = 0;
voicing_[i] = 1;
}
}
+
+ for(i=0; i<M; i++) {
+ L_[i] = floorf(M_PI/Wo_[i]);
+ }
}
\*---------------------------------------------------------------------------*/
-void determine_phase(MODEL *model, int Nfft, codec2_fft_cfg fwd_cfg, codec2_fft_cfg inv_cfg)
+void determine_phase(COMP H[], MODEL *model, int Nfft, codec2_fft_cfg fwd_cfg, codec2_fft_cfg inv_cfg)
{
int i,m,b;
int Ns = Nfft/2+1;
for(m=1; m<=model->L; m++) {
b = floorf(0.5+m*model->Wo*Nfft/(2.0*M_PI));
- model->phi[m] = phase[b];
+ H[m].real = cos(phase[b]); H[m].imag = -sin(phase[b]);
}
}
/*---------------------------------------------------------------------------*\
- FUNCTION....: newamp1_indexes_to_model
+ FUNCTION....: newamp1_interpolate
+ AUTHOR......: David Rowe
+ DATE CREATED: Jan 2017
+
+\*---------------------------------------------------------------------------*/
+
+void newamp1_interpolate(float interpolated_surface_[], float left_vec[], float right_vec[], int K)
+{
+ int i, k;
+ int M = 4;
+ float c;
+
+ /* (linearly) interpolate 25Hz amplitude vectors back to 100Hz */
+
+ for(i=0,c=1.0; i<M; i++,c-=1.0/M) {
+ for(k=0; k<K; k++) {
+ interpolated_surface_[i*K+k] = left_vec[k]*c + right_vec[k]*(1.0-c);
+ }
+ }
+}
+
+
+/*---------------------------------------------------------------------------*\
+
+ FUNCTION....: newamp1_indexes_to_rate_K_vec
AUTHOR......: David Rowe
DATE CREATED: Jan 2017
newamp1 decoder for amplitudes {Am}. Given the rate K VQ and energy
- indexes at a 25Hz sample rate, outputs 4 100Hz rate L model structures.
+ indexes, outputs rate K vector.
\*---------------------------------------------------------------------------*/
-void newamp1_indexes_to_model(float rate_K_vec_[],
- float rate_K_vec_no_mean_[],
- float rate_K_sample_freqs_kHz[],
- int K,
- float *mean_,
- int indexes[])
+void newamp1_indexes_to_rate_K_vec(float rate_K_vec_[],
+ float rate_K_vec_no_mean_[],
+ float rate_K_sample_freqs_kHz[],
+ int K,
+ float *mean_,
+ int indexes[])
{
int k;
const float *codebook1 = newamp1vq_cb[0].cb;
}
}
+
+/*---------------------------------------------------------------------------*\
+
+ FUNCTION....: newamp1_indexes_to_model
+ AUTHOR......: David Rowe
+ DATE CREATED: Jan 2017
+
+ newamp1 decoder.
+
+\*---------------------------------------------------------------------------*/
+
+void newamp1_indexes_to_model(MODEL model_[],
+ COMP H[],
+ float *interpolated_surface_,
+ float prev_rate_K_vec_[],
+ float *Wo_left,
+ int *voicing_left,
+ float rate_K_sample_freqs_kHz[],
+ int K,
+ codec2_fft_cfg fwd_cfg,
+ codec2_fft_cfg inv_cfg,
+ int indexes[])
+{
+ float rate_K_vec_[K], rate_K_vec_no_mean_[K], mean_, Wo_right;
+ int voicing_right, k;
+ int M = 4;
+
+ /* extract latest rate K vector */
+
+ newamp1_indexes_to_rate_K_vec(rate_K_vec_,
+ rate_K_vec_no_mean_,
+ rate_K_sample_freqs_kHz,
+ K,
+ &mean_,
+ indexes);
+
+
+ /* decode latest Wo and voicing */
+
+ if (indexes[3]) {
+ Wo_right = decode_log_Wo(indexes[3], 6);
+ voicing_right = 1;
+ }
+ else {
+ Wo_right = 2.0*M_PI/100.0;
+ voicing_right = 0;
+ }
+
+ /* interpolate 25Hz rate K vec back to 100Hz */
+
+ float *left_vec = prev_rate_K_vec_;
+ float *right_vec = rate_K_vec_;
+ newamp1_interpolate(interpolated_surface_, left_vec, right_vec, K);
+
+ /* interpolate 25Hz v and Wo back to 100Hz */
+
+ float aWo_[M];
+ int avoicing_[M], aL_[M], i;
+
+ interp_Wo_v(aWo_, aL_, avoicing_, *Wo_left, Wo_right, *voicing_left, voicing_right);
+
+ /* back to rate L amplitudes, synthesis phase for each frame */
+
+ for(i=0; i<M; i++) {
+ model_[i].Wo = aWo_[i];
+ model_[i].L = aL_[i];
+ model_[i].voiced = avoicing_[i];
+
+ resample_rate_L(&model_[i], &interpolated_surface_[K*i], rate_K_sample_freqs_kHz, K);
+ determine_phase(&H[(MAX_AMP+1)*i], &model_[i], NEWAMP1_PHASE_NFFT, fwd_cfg, inv_cfg);
+ }
+
+ /* update memories for next time */
+
+ for(k=0; k<K; k++) {
+ prev_rate_K_vec_[k] = rate_K_vec_[k];
+ }
+ *Wo_left = Wo_right;
+ *voicing_left = voicing_right;
+
+}
+
#ifndef __NEWAMP1__
#define __NEWAMP1__
-#define NEWAMP1_N_INDEXES 4 /* Number of indexes to pack: vq1, vq2, energy, Wo */
+#define NEWAMP1_N_INDEXES 4 /* Number of indexes to pack: vq1, vq2, energy, Wo */
+#define NEWAMP1_PHASE_NFFT 128 /* size of FFT used for phase synthesis */
#include "codec2_fft.h"
#include "comp.h"
void resample_const_rate_f(MODEL *model, float rate_K_vec[], float rate_K_sample_freqs_kHz[], int K);
float rate_K_mbest_encode(int *indexes, float *x, float *xq, int ndim, int mbest_entries);
void post_filter_newamp1(float vec[], float sample_freq_kHz[], int K, float pf_gain);
-void interp_Wo_v(float Wo_[], int voicing_[], float Wo1, float Wo2, int voicing1, int voicing2);
+void interp_Wo_v(float Wo_[], int L_[], int voicing_[], float Wo1, float Wo2, int voicing1, int voicing2);
void resample_rate_L(MODEL *model, float rate_K_vec[], float rate_K_sample_freqs_kHz[], int K);
-void determine_phase(MODEL *model, int Nfft, codec2_fft_cfg fwd_cfg, codec2_fft_cfg inv_cfg);
+void determine_phase(COMP H[], MODEL *model, int Nfft, codec2_fft_cfg fwd_cfg, codec2_fft_cfg inv_cfg);
void newamp1_model_to_indexes(int indexes[],
MODEL *model,
float rate_K_vec[],
float rate_K_vec_no_mean[],
float rate_K_vec_no_mean_[]
);
-void newamp1_indexes_to_model(float rate_K_vec_[],
- float rate_K_vec_no_mean_[],
+void newamp1_indexes_to_rate_K_vec(float rate_K_vec_[],
+ float rate_K_vec_no_mean_[],
+ float rate_K_sample_freqs_kHz[],
+ int K,
+ float *mean_,
+ int indexes[]);
+void newamp1_interpolate(float interpolated_surface_[], float left_vec[], float right_vec[], int K);
+
+void newamp1_indexes_to_model(MODEL model_[],
+ COMP H[],
+ float interpolated_surface_[],
+ float prev_rate_K_vec_[],
+ float *Wo_left,
+ int *voicing_left,
float rate_K_sample_freqs_kHz[],
int K,
- float *mean_,
+ codec2_fft_cfg fwd_cfg,
+ codec2_fft_cfg inv_cfg,
int indexes[]);
#endif
#include "quantise.h"
#define FRAMES 100
-#define PHASE_NFFT 128
int main(int argc, char *argv[]) {
short buf[N_SAMP]; /* input/output buffer */
fft_fwd_cfg = codec2_fft_alloc(FFT_ENC, 0, NULL, NULL);
make_analysis_window(fft_fwd_cfg, w, W);
- phase_fft_fwd_cfg = codec2_fft_alloc(PHASE_NFFT, 0, NULL, NULL);
- phase_fft_inv_cfg = codec2_fft_alloc(PHASE_NFFT, 1, NULL, NULL);
+ phase_fft_fwd_cfg = codec2_fft_alloc(NEWAMP1_PHASE_NFFT, 0, NULL, NULL);
+ phase_fft_inv_cfg = codec2_fft_alloc(NEWAMP1_PHASE_NFFT, 1, NULL, NULL);
for(i=0; i<M_PITCH; i++) {
Sn[i] = 1.0;
int voicing[FRAMES];
int voicing_[FRAMES];
float model_octave_[FRAMES][MAX_AMP+2];
- COMP Hm[FRAMES][MAX_AMP];
+ COMP H[FRAMES][MAX_AMP];
int indexes[FRAMES][NEWAMP1_N_INDEXES];
for(f=0; f<FRAMES; f++) {
model_octave_[f][m] = 0.0;
}
for(m=0; m<MAX_AMP; m++) {
- Hm[f][m].real = 0.0;
- Hm[f][m].imag = 0.0;
+ H[f][m].real = 0.0;
+ H[f][m].imag = 0.0;
}
for(k=0; m<K; k++)
interpolated_surface_[f][k] = 0.0;
&rate_K_surface_no_mean[f][0],
&rate_K_surface_no_mean_[f][0]);
- newamp1_indexes_to_model(&rate_K_surface_[f][0],
- &rate_K_surface_no_mean_[f][0],
- rate_K_sample_freqs_kHz,
- K,
- &mean_[f],
- &indexes[f][0]);
+ newamp1_indexes_to_rate_K_vec(&rate_K_surface_[f][0],
+ &rate_K_surface_no_mean_[f][0],
+ rate_K_sample_freqs_kHz,
+ K,
+ &mean_[f],
+ &indexes[f][0]);
/* log vectors */
/* Decoder */
- MODEL model_;
+ MODEL model__[M];
+ float prev_rate_K_vec_[K];
+ COMP HH[M][MAX_AMP+1];
+ float Wo_left;
+ int voicing_left;
+
+ for(k=0; k<K; k++)
+ prev_rate_K_vec_[k] = rate_K_surface_[0][k];
for(f=0; f<FRAMES; f+=M) {
pass in left and right rate K vectors, Wo, v
interpolate at rate K
convert to rate L
- output 4 model parameters
+ indexes for current plus decoded rate K, Wo, v from frame[0], model[4] out parameters,
+ then plug them into model_octave for testing
ref indexes to 0...3
slowly change
+
+ [ ] model[4] out
+ [ ] change to 1:M processing
+ + not sure how to handle Octave side of this
*/
- float c;
- if (f >= M) {
-
- /* interpolate 25Hz amplitude vectors back to 100Hz */
+ if (f >= M) {
+ /*
float *left_vec = &rate_K_surface_[f-M][0];
float *right_vec = &rate_K_surface_[f][0];
- for(i=f-M,c=1.0; i<f; i++,c-=1.0/M) {
- for(k=0; k<K; k++) {
- interpolated_surface_[i][k] = left_vec[k]*c + right_vec[k]*(1.0-c);
- }
- }
-
+ newamp1_interpolate(&interpolated_surface_[f-M][0], left_vec, right_vec, K);
+ */
+
+ Wo_left = model_octave_[f-M][0];
+ voicing_left = voicing[f-M];
+
+ newamp1_indexes_to_model(model__,
+ (COMP*)HH,
+ &interpolated_surface_[f-M][0],
+ prev_rate_K_vec_,
+ &Wo_left,
+ &voicing_left,
+ rate_K_sample_freqs_kHz,
+ K,
+ phase_fft_fwd_cfg,
+ phase_fft_inv_cfg,
+ &indexes[f][0]);
+
/* interpolate 25Hz v and Wo back to 100Hz */
float aWo_[M];
- int avoicing_[M], m;
+ int avoicing_[M], aL_[M], m;
float Wo1 = model_octave_[f-M][0];
float Wo2 = model_octave_[f][0];
- interp_Wo_v(aWo_, avoicing_, Wo1, Wo2, voicing[f-M], voicing[f]);
+ interp_Wo_v(aWo_, aL_, avoicing_, Wo1, Wo2, voicing[f-M], voicing[f]);
+
for(i=f-M, m=0; i<f; i++,m++) {
- model_octave_[i][0] = aWo_[m];
- model_octave_[i][1] = floorf(M_PI/model_octave_[i][0]);
+ model_octave_[i][0] = model__[m].Wo; //aWo_[m];
+ model_octave_[i][1] = model__[m].L; //aL_[m];
voicing_[i] = avoicing_[m];
}
/* back to rate L, synth phase */
- for(i=f-M; i<f; i++) {
+ MODEL model_;
+ COMP aH[MAX_AMP+1];
+ int j;
+ for(i=f-M, j=0; i<f; i++,j++) {
+ /*
model_.Wo = model_octave_[i][0];
model_.L = model_octave_[i][1];
resample_rate_L(&model_, &interpolated_surface_[i][0], rate_K_sample_freqs_kHz, K);
- //printf("\n");
- //printf("frame: %d Wo: %4.3f L: %d\n", i+1, model_.Wo, model_.L);
- determine_phase(&model_, PHASE_NFFT, phase_fft_fwd_cfg, phase_fft_inv_cfg);
- //if (i == 1) {
- // exit(0);
- //}
-
+ determine_phase(aH, &model_, NEWAMP1_PHASE_NFFT, phase_fft_fwd_cfg, phase_fft_inv_cfg);
+ */
+ model_.L = model_octave_[i][1];
for(m=1; m<=model_.L; m++) {
- model_octave_[i][m+1] = model_.A[m];
- Hm[i][m-1].real = cos(model_.phi[m]);
- Hm[i][m-1].imag = -sin(model_.phi[m]);
- //printf("m: %d Hm: %f %f\n", m, Hm[i][m].real, Hm[i][m].imag);
- }
+ model_octave_[i][m+1] = model__[j].A[m]; // = model_.A[m];
+ H[i][m-1] = HH[j][m];// aH[m];
+ }
}
-
}
-
}
fclose(fin);
octave_save_float(fout, "model_c", (float*)model_octave, FRAMES, MAX_AMP+2, MAX_AMP+2);
octave_save_float(fout, "model__c", (float*)model_octave_, FRAMES, MAX_AMP+2, MAX_AMP+2);
octave_save_int(fout, "voicing__c", (int*)voicing_, 1, FRAMES);
- octave_save_complex(fout, "Hm_c", (COMP*)Hm, FRAMES, MAX_AMP, MAX_AMP);
+ octave_save_complex(fout, "H_c", (COMP*)H, FRAMES, MAX_AMP, MAX_AMP);
fclose(fout);
printf("Done! Now run\n octave:1> tnewamp1(\"../build_linux/src/hts1a\")\n");
projects / freetel-svn-tracking.git / commitdiff