model to indexes and indexes to model at 100Hz

git-svn-id: https://svn.code.sf.net/p/freetel/code@2956 01035d8c-6547-0410-b346-abe4f91aad63

diff --git a/codec2-dev/src/newamp1.c b/codec2-dev/src/newamp1.c
index 45fe39b1d2be1e8ffdb74cc6888222d82578f3c7..260255434132644da2f9ea003b086e422617f626 100644 (file)
--- a/codec2-dev/src/newamp1.c
+++ b/codec2-dev/src/newamp1.c
@@ -40,6 +40,9 @@
 #include "mbest.h"
 #include "newamp1.h"
 
+#define NEWAMP1_VQ_MBEST_DEPTH 5  /* how many candidates we keep for each stage of mbest search */
+#define NEWAMP1_VQ_STAGES   2     /* hard coded two stage VQ */
+
 /*---------------------------------------------------------------------------*\
 
   FUNCTION....: interp_para()
@@ -171,6 +174,12 @@ float rate_K_mbest_encode(int *indexes, float *x, float *xq, int ndim, int mbest
   int   index[MBEST_STAGES];
   float mse, tmp;
 
+  /* codebook is compiled for a fixed K */
+
+  assert(ndim == newamp1vq_cb[0].k);
+
+  /* equal weights, could be argued mel freq axis gives freq dep weighting */
+
   for(i=0; i<ndim; i++)
       w[i] = 1.0;
 
@@ -206,7 +215,7 @@ float rate_K_mbest_encode(int *indexes, float *x, float *xq, int ndim, int mbest
   mbest_destroy(mbest_stage1);
   mbest_destroy(mbest_stage2);
 
-  indexes[0] = n1; indexes[1] = n2;;
+  indexes[0] = n1; indexes[1] = n2;
 
   return mse;
 }
@@ -403,3 +412,92 @@ void determine_phase(MODEL *model, int Nfft, codec2_fft_cfg fwd_cfg, codec2_fft_
     }
     printf("\n");
 }
+
+
+/*---------------------------------------------------------------------------*\
+
+  FUNCTION....: newamp1_model_to_indexes
+  AUTHOR......: David Rowe
+  DATE CREATED: Jan 2017
+
+  newamp1 encoder for amplitdues {Am}.  Given the rate L model
+  parameters, outputs VQ and energy quantiser indexes.
+
+\*---------------------------------------------------------------------------*/
+
+void newamp1_model_to_indexes(int    indexes[], 
+                              MODEL *model, 
+                              float  rate_K_vec[], 
+                              float  rate_K_sample_freqs_kHz[], 
+                              int    K,
+                              float *mean,
+                              float  rate_K_vec_no_mean[], 
+                              float  rate_K_vec_no_mean_[]
+                              )
+{
+    int k;
+
+    /* convert variable rate L to fixed rate K */
+
+    resample_const_rate_f(model, rate_K_vec, rate_K_sample_freqs_kHz, K);
+
+    /* remove mean and two stage VQ */
+
+    float sum = 0.0;
+    for(k=0; k<K; k++)
+        sum += rate_K_vec[k];
+    *mean = sum/K;
+    for(k=0; k<K; k++)
+        rate_K_vec_no_mean[k] = rate_K_vec[k] - *mean;
+    rate_K_mbest_encode(indexes, rate_K_vec_no_mean, rate_K_vec_no_mean_, K, NEWAMP1_VQ_MBEST_DEPTH);
+
+    /* scalar quantise mean (effectively the frame energy) */
+
+    float w[1] = {1.0};
+    float se;
+    indexes[NEWAMP1_VQ_STAGES] = quantise(newamp1_energy_cb[0].cb, 
+                                          mean, 
+                                          w, 
+                                          newamp1_energy_cb[0].k, 
+                                          newamp1_energy_cb[0].m, 
+                                          &se);
+ }
+
+
+/*---------------------------------------------------------------------------*\
+
+  FUNCTION....: newamp1_indexes_to_model
+  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.
+
+\*---------------------------------------------------------------------------*/
+
+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[])
+{
+    int   k;
+    const float *codebook1 = newamp1vq_cb[0].cb;
+    const float *codebook2 = newamp1vq_cb[1].cb;
+    int n1 = indexes[0];
+    int n2 = indexes[1];
+    
+    for(k=0; k<K; k++) {
+      rate_K_vec_no_mean_[k] = codebook1[K*n1+k] + codebook2[K*n2+k];
+    }
+
+    post_filter_newamp1(rate_K_vec_no_mean_, rate_K_sample_freqs_kHz, K, 1.5);
+
+    *mean_ = newamp1_energy_cb[0].cb[indexes[NEWAMP1_VQ_STAGES]];
+
+    for(k=0; k<K; k++) {
+        rate_K_vec_[k] = rate_K_vec_no_mean_[k] + *mean_;
+    }
+}
+

diff --git a/codec2-dev/src/newamp1.h b/codec2-dev/src/newamp1.h
index e576a1f3a9ddd1ea1162771222bd87f6660f78e6..fe59d8989c6c4895bf5718ec85d303ea86232453 100644 (file)
--- a/codec2-dev/src/newamp1.h
+++ b/codec2-dev/src/newamp1.h
@@ -42,5 +42,20 @@ void post_filter_newamp1(float vec[], float sample_freq_kHz[], int K, float pf_g
 void interp_Wo_v(float Wo_[], 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 newamp1_model_to_indexes(int    indexes[], 
+                              MODEL *model, 
+                              float  rate_K_vec[], 
+                              float  rate_K_sample_freqs_kHz[], 
+                              int    K,
+                              float *mean,
+                              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_[],
+                              float  rate_K_sample_freqs_kHz[], 
+                              int    K,
+                              float *mean_,
+                              int    indexes[]);
 
 #endif

diff --git a/codec2-dev/unittest/tnewamp1.c b/codec2-dev/unittest/tnewamp1.c
index 5af420e5e10848cfc30cd4c5011f296f38ab696e..36fea32484761faaedc85d18a36bf0b7a95b49ca 100644 (file)
--- a/codec2-dev/unittest/tnewamp1.c
+++ b/codec2-dev/unittest/tnewamp1.c
@@ -34,6 +34,7 @@
 #include "nlp.h"
 #include "dump.h"
 #include "octave.h"
+#include "newamp1.h"
 #include "quantise.h"
 
 #define FRAMES 100
@@ -135,31 +136,22 @@ int main(int argc, char *argv[]) {
 
         /* newamp1 processing ----------------------------------------*/
 
-        resample_const_rate_f(&model, &rate_K_surface[f][0], rate_K_sample_freqs_kHz, K);
-        float sum = 0.0;
-        for(k=0; k<K; k++)
-            sum += rate_K_surface[f][k];
-        mean[f] = sum/K;
-        for(k=0; k<K; k++)
-            rate_K_surface_no_mean[f][k] = rate_K_surface[f][k] - mean[f];
-
-        int vq_indexes[2];
-        rate_K_mbest_encode(vq_indexes, &rate_K_surface_no_mean[f][0], &rate_K_surface_no_mean_[f][0], K, 5);
-
-        post_filter_newamp1(&rate_K_surface_no_mean_[f][0], rate_K_sample_freqs_kHz, K, 1.5);
-
-        int energy_index;
-        float w[1] = {1.0};
-        float se;
-        energy_index = quantise(newamp1_energy_cb[0].cb, &mean[f], w, newamp1_energy_cb[0].k, newamp1_energy_cb[0].m, &se);
-        mean_[f] = newamp1_energy_cb[0].cb[energy_index];
-
-        for(k=0; k<K; k++)
-            rate_K_surface_[f][k] = rate_K_surface_no_mean_[f][k] + mean_[f];
-
-        //for(int k=0; k<K; k++)
-        //    printf("k: %d sf: %f sv: %f\n", k, rate_K_sample_freqs_kHz[k], rate_K_surface[f][k]);
-        //printf("\n");
+        int indexes[3];
+        newamp1_model_to_indexes(indexes, 
+                                 &model, 
+                                 &rate_K_surface[f][0], 
+                                 rate_K_sample_freqs_kHz,
+                                 K,
+                                 &mean[f],
+                                 &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);
 
         /* log vectors */