Converted filters with memory to direct form II transposed, this creates
authorjmvalin <jmvalin@0101bb08-14d6-0310-b084-bc0e0c8e3800>
Fri, 20 Sep 2002 03:37:31 +0000 (03:37 +0000)
committerjmvalin <jmvalin@0101bb08-14d6-0310-b084-bc0e0c8e3800>
Fri, 20 Sep 2002 03:37:31 +0000 (03:37 +0000)
a "minor incompatibility"...

git-svn-id: http://svn.xiph.org/trunk/speex@3929 0101bb08-14d6-0310-b084-bc0e0c8e3800

libspeex/filters.c
libspeex/filters.h
libspeex/nb_celp.c
libspeex/nb_celp.h
libspeex/sb_celp.c

index cfdf8c9..bbfc36c 100644 (file)
@@ -149,6 +149,54 @@ void residue_mem(float *x, float *a, float *y, int N, int ord, float *mem)
       mem[i]=x[N-i-1];
 }
 
+
+void filter_mem2(float *x, float *num, float *den, float *y, int N, int ord, float *mem)
+{
+   int i,j;
+   float xi;
+   for (i=0;i<N;i++)
+   {
+      xi=x[i];
+      y[i] = num[0]*xi + mem[0];
+      for (j=0;j<ord-1;j++)
+      {
+         mem[j] = mem[j+1] + num[j+1]*xi - den[j+1]*y[i];
+      }
+      mem[ord-1] = num[ord]*xi - den[ord]*y[i];
+   }
+}
+
+void fir_mem2(float *x, float *num, float *y, int N, int ord, float *mem)
+{
+   int i,j;
+   float xi;
+   for (i=0;i<N;i++)
+   {
+      xi=x[i];
+      y[i] = num[0]*xi + mem[0];
+      for (j=0;j<ord-1;j++)
+      {
+         mem[j] = mem[j+1] + num[j+1]*xi;
+      }
+      mem[ord-1] = num[ord]*xi;
+   }
+}
+
+void iir_mem2(float *x, float *den, float *y, int N, int ord, float *mem)
+{
+   int i,j;
+   for (i=0;i<N;i++)
+   {
+      y[i] = x[i] + mem[0];
+      for (j=0;j<ord-1;j++)
+      {
+         mem[j] = mem[j+1] - den[j+1]*y[i];
+      }
+      mem[ord-1] = - den[ord]*y[i];
+   }
+}
+
+
 void pole_zero_mem(float *x, float *num, float *den, float *y, int N, int ord, float *mem, float *stack)
 {
    float *tmp=PUSH(stack, N);
@@ -243,7 +291,7 @@ void syn_percep_zero(float *xx, float *ak, float *awk1, float *awk2, float *y, i
 #endif
 }
 
-
+#if 1
 #define MAX_FILTER 100
 #define MAX_SIGNAL 1000
 void fir_mem(float *xx, float *aa, float *y, int N, int M, float *mem)
@@ -266,7 +314,12 @@ void fir_mem(float *xx, float *aa, float *y, int N, int M, float *mem)
    for (i=0;i<M-1;i++)
      mem[i]=xx[N-i-1];
 }
-
+#else
+void fir_mem(float *xx, float *aa, float *y, int N, int M, float *mem)
+{
+   fir_mem2(xx, aa, y, N, M-1, mem);
+}
+#endif
 
 void comb_filter(
 float *exc,          /*decoded excitation*/
index ba09dff..d856046 100644 (file)
 
 void print_vec(float *vec, int len, char *name);
 
+void filter_mem2(float *x, float *num, float *den, float *y, int N, int ord, float *mem);
+void fir_mem2(float *x, float *num, float *y, int N, int ord, float *mem);
+void iir_mem2(float *x, float *den, float *y, int N, int ord, float *mem);
+
 /* Apply bandwidth expansion on LPC coef */
 void bw_lpc(float gamma, float *lpc_in, float *lpc_out, int order);
 
@@ -32,23 +36,32 @@ void enh_lpc(float *ak, int order, float *num, float *den, float k1, float k2, f
 /*LPC polynomial "flatifier"*/
 void lpc_flat(float g1, float g2, float *lpc_in, float *lpc_out1, float *lpc_out2, int order);
 
+
+#if 0
 /* Synthesis filter using the past of y[n] (negative indices) as memory */
 void syn_filt(float *x, float *a, float *y, int N, int ord);
+#endif
 
 /* Synthesis filter using zero memory */
 void syn_filt_zero(float *x, float *a, float *y, int N, int ord);
 
+#if 0
 /* Synthesis filter using memory */
 void syn_filt_mem(float *x, float *a, float *y, int N, int ord, float *mem);
 
 /* Analysis (FIR) filter using the past of x[n] (negative indices) as memory */
 void residue(float *x, float *a, float *y, int N, int ord);
+#endif
 
 /* Analysis (FIR) filter using zero memory */
 void residue_zero(float *x, float *a, float *y, int N, int ord);
 
+#if 0
 /* Analysis (FIR) filter using memory */
 void residue_mem(float *x, float *a, float *y, int N, int ord, float *mem);
+#endif
+
+
 
 /* FIR filter */
 void fir_mem(float *x, float *a, float *y, int N, int M, float *mem);
index 77a6de1..3f69255 100644 (file)
@@ -42,7 +42,7 @@ extern int training_weight;
 float exc_gain_quant_scal3[8]={-2.794750, -1.810660, -1.169850, -0.848119, -0.587190, -0.329818, -0.063266, 0.282826};
 
 float exc_gain_quant_scal1[2]={-0.35, 0.05};
+/*float exc_gain_quant_scal1[2]={-0.35, 0.05};*/
 
 #define sqr(x) ((x)*(x))
 #define min(a,b) ((a) < (b) ? (a) : (b))
@@ -129,6 +129,7 @@ void *nb_encoder_init(SpeexMode *m)
 
    st->mem_sp = speex_alloc(st->lpcSize*sizeof(float));
    st->mem_sw = speex_alloc(st->lpcSize*sizeof(float));
+   st->mem_exc = speex_alloc(st->lpcSize*sizeof(float));
 
    st->pi_gain = speex_alloc(st->nbSubframes*sizeof(float));
 
@@ -178,6 +179,7 @@ void nb_encoder_destroy(void *state)
 
    speex_free(st->mem_sp);
    speex_free(st->mem_sw);
+   speex_free(st->mem_exc);
    speex_free(st->pi_gain);
    speex_free(st->pitch);
 
@@ -253,6 +255,8 @@ void nb_encode(void *state, float *in, SpeexBits *bits)
 
    /* Whole frame analysis (open-loop estimation of pitch and excitation gain) */
    {
+      /*FIXME: stack alloc*/
+      static float mem[10];
       for (i=0;i<st->lpcSize;i++)
          st->interp_lsp[i] = .5*st->old_lsp[i] + .5*st->lsp[i];
 
@@ -266,9 +270,10 @@ void nb_encode(void *state, float *in, SpeexBits *bits)
       bw_lpc(st->gamma1, st->interp_lpc, st->bw_lpc1, st->lpcSize);
       bw_lpc(st->gamma2, st->interp_lpc, st->bw_lpc2, st->lpcSize);
 
-      residue(st->frame, st->bw_lpc1, st->exc, st->frameSize, st->lpcSize);
-      syn_filt(st->exc, st->bw_lpc2, st->sw, st->frameSize, st->lpcSize);
-      
+      for (i=0;i<st->lpcSize;i++)
+         mem[i]=st->mem_sw[i];
+      filter_mem2(st->frame, st->bw_lpc1, st->bw_lpc2, st->sw, st->frameSize, st->lpcSize, mem);
+
       /*Open-loop pitch*/
       {
          int nol_pitch[4];
@@ -292,7 +297,7 @@ void nb_encode(void *state, float *in, SpeexBits *bits)
          /*printf ("ol_pitch: %d %f\n", ol_pitch, ol_pitch_coef);*/
       }
       /*Compute "real" excitation*/
-      residue(st->frame, st->interp_lpc, st->exc, st->frameSize, st->lpcSize);
+      fir_mem2(st->frame, st->interp_lpc, st->exc, st->frameSize, st->lpcSize, st->mem_exc);
 
       /* Compute open-loop excitation gain */
       ol_gain=0;
@@ -342,7 +347,7 @@ void nb_encode(void *state, float *in, SpeexBits *bits)
       st->first=1;
 
       /* Final signal synthesis from excitation */
-      syn_filt_mem(st->exc, st->interp_qlpc, st->frame, st->subframeSize, st->lpcSize, st->mem_sp);
+      iir_mem2(st->exc, st->interp_qlpc, st->frame, st->subframeSize, st->lpcSize, st->mem_sp);
 
       in[0] = st->frame[0] + st->preemph*st->pre_mem2;
       for (i=1;i<st->frameSize;i++)
@@ -474,22 +479,18 @@ void nb_encode(void *state, float *in, SpeexBits *bits)
       /* Compute zero response of A(z/g1) / ( A(z/g2) * A(z) ) */
       for (i=0;i<st->lpcSize;i++)
          mem[i]=st->mem_sp[i];
-      syn_filt_mem(exc, st->interp_qlpc, exc, st->subframeSize, st->lpcSize, mem);
-      for (i=0;i<st->lpcSize;i++)
-         mem[i]=st->mem_sp[i];
-      residue_mem(exc, st->bw_lpc1, res, st->subframeSize, st->lpcSize, mem);
+      iir_mem2(exc, st->interp_qlpc, exc, st->subframeSize, st->lpcSize, mem);
+      
+
       for (i=0;i<st->lpcSize;i++)
          mem[i]=st->mem_sw[i];
-      syn_filt_mem(res, st->bw_lpc2, res, st->subframeSize, st->lpcSize, mem);
+      filter_mem2(exc, st->bw_lpc1, st->bw_lpc2, res, st->subframeSize, st->lpcSize, mem);
 
       /* Compute weighted signal */
       for (i=0;i<st->lpcSize;i++)
-         mem[i]=st->mem_sp[i];
-      residue_mem(sp, st->bw_lpc1, sw, st->subframeSize, st->lpcSize, mem);
-      for (i=0;i<st->lpcSize;i++)
          mem[i]=st->mem_sw[i];
-      syn_filt_mem(sw, st->bw_lpc2, sw, st->subframeSize, st->lpcSize, mem);
-      
+      filter_mem2(sp, st->bw_lpc1, st->bw_lpc2, sw, st->subframeSize, st->lpcSize, mem);
+
       esig=0;
       for (i=0;i<st->subframeSize;i++)
          esig+=sw[i]*sw[i];
@@ -661,12 +662,10 @@ void nb_encode(void *state, float *in, SpeexBits *bits)
       for (i=0;i<st->lpcSize;i++)
          mem[i]=st->mem_sp[i];
       /* Final signal synthesis from excitation */
-      syn_filt_mem(exc, st->interp_qlpc, sp, st->subframeSize, st->lpcSize, st->mem_sp);
+      iir_mem2(exc, st->interp_qlpc, sp, st->subframeSize, st->lpcSize, st->mem_sp);
 
       /* Compute weighted signal again, from synthesized speech (not sure it's the right thing) */
-      residue_mem(sp, st->bw_lpc1, sw, st->subframeSize, st->lpcSize, mem);
-      syn_filt_mem(sw, st->bw_lpc2, sw, st->subframeSize, st->lpcSize, st->mem_sw);
-
+      filter_mem2(sp, st->bw_lpc1, st->bw_lpc2, sw, st->subframeSize, st->lpcSize, st->mem_sw);
       for (i=0;i<st->subframeSize;i++)
          exc2[i]=exc[i];
 
@@ -806,9 +805,11 @@ static void nb_decode_lost(DecState *st, float *out)
       for (i=0;i<st->subframeSize;i++)
          sp[i]=exc[i];
       
-      pole_zero_mem(sp, num, den, sp, st->subframeSize, (st->lpcSize<<1), 
-                    st->mem_sp+st->lpcSize, st->stack);
-      syn_filt_mem(sp, st->interp_qlpc, sp, st->subframeSize, st->lpcSize, 
+      /*pole_zero_mem(sp, num, den, sp, st->subframeSize, (st->lpcSize<<1), 
+                    st->mem_sp+st->lpcSize, st->stack);*/
+      filter_mem2(sp, num, den, sp, st->subframeSize, (st->lpcSize<<1), 
+        st->mem_sp+st->lpcSize);
+      iir_mem2(sp, st->interp_qlpc, sp, st->subframeSize, st->lpcSize, 
         st->mem_sp);
       
       POP(st->stack);
@@ -893,7 +894,7 @@ int nb_decode(void *state, SpeexBits *bits, float *out)
       st->first=1;
       
       /* Final signal synthesis from excitation */
-      syn_filt_mem(st->exc, st->interp_qlpc, st->frame, st->subframeSize, st->lpcSize, st->mem_sp);
+      iir_mem2(st->exc, st->interp_qlpc, st->frame, st->subframeSize, st->lpcSize, st->mem_sp);
 
       out[0] = st->frame[0] + st->preemph*st->pre_mem;
       for (i=1;i<st->frameSize;i++)
@@ -1088,9 +1089,11 @@ int nb_decode(void *state, SpeexBits *bits, float *out)
       if (st->lpc_enh_enabled && SUBMODE(comb_gain>0))
          comb_filter(exc, sp, st->interp_qlpc, st->lpcSize, st->subframeSize,
                               pitch, pitch_gain, .5);
-      pole_zero_mem(sp, num, den, sp, st->subframeSize, (st->lpcSize<<1), 
-                    st->mem_sp+st->lpcSize, st->stack);
-      syn_filt_mem(sp, st->interp_qlpc, sp, st->subframeSize, st->lpcSize, 
+      /*pole_zero_mem(sp, num, den, sp, st->subframeSize, (st->lpcSize<<1), 
+        st->mem_sp+st->lpcSize, st->stack);*/
+      filter_mem2(sp, num, den, sp, st->subframeSize, (st->lpcSize<<1), 
+        st->mem_sp+st->lpcSize);
+      iir_mem2(sp, st->interp_qlpc, sp, st->subframeSize, st->lpcSize, 
         st->mem_sp);
       
       POP(st->stack);
index ebe2c58..7753012 100644 (file)
@@ -78,7 +78,9 @@ typedef struct EncState {
    float *rc;             /**< Reflection coefficients */
    float *mem_sp;         /**< Filter memory for signal synthesis */
    float *mem_sw;         /**< Filter memory for perceptually-weighted signal */
+   float *mem_exc;        /**< Filter memory for excitation */
    float *pi_gain;        /**< Gain of LPC filter at theta=pi (fe/2) */
+
    VBRState *vbr;         /**< State of the VBR data */
    int    vbr_quality;    /**< Quality setting for VBR encoding */
    int    vbr_enabled;    /**< 1 for enabling VBR, 0 otherwise */
index 2f1b924..66c790e 100644 (file)
@@ -325,7 +325,7 @@ void sb_encode(void *state, float *in, SpeexBits *bits)
       st->first=1;
 
       /* Final signal synthesis from excitation */
-      syn_filt_mem(st->exc, st->interp_qlpc, st->high, st->subframeSize, st->lpcSize, st->mem_sp);
+      iir_mem2(st->exc, st->interp_qlpc, st->high, st->subframeSize, st->lpcSize, st->mem_sp);
 
 #ifndef RELEASE
       /* Up-sample coded low-band and high-band*/
@@ -425,7 +425,7 @@ void sb_encode(void *state, float *in, SpeexBits *bits)
       fold=0;
 
       /* Compute "real excitation" */
-      residue_mem(sp, st->interp_qlpc, exc, st->subframeSize, st->lpcSize, st->mem_sp2);
+      fir_mem2(sp, st->interp_qlpc, exc, st->subframeSize, st->lpcSize, st->mem_sp2);
       /* Compute energy of low-band and high-band excitation */
       for (i=0;i<st->subframeSize;i++)
          eh+=sqr(exc[i]);
@@ -498,13 +498,24 @@ void sb_encode(void *state, float *in, SpeexBits *bits)
          /* Compute zero response (ringing) of A(z/g1) / ( A(z/g2) * Aq(z) ) */
          for (i=0;i<st->lpcSize;i++)
             mem[i]=st->mem_sp[i];
-         syn_filt_mem(exc, st->interp_qlpc, exc, st->subframeSize, st->lpcSize, mem);
+         iir_mem2(exc, st->interp_qlpc, exc, st->subframeSize, st->lpcSize, mem);
+
+         for (i=0;i<st->lpcSize;i++)
+            mem[i]=st->mem_sw[i];
+         filter_mem2(exc, st->bw_lpc1, st->bw_lpc2, res, st->subframeSize, st->lpcSize, mem);
+
+         /* Compute weighted signal */
          for (i=0;i<st->lpcSize;i++)
+            mem[i]=st->mem_sw[i];
+         filter_mem2(sp, st->bw_lpc1, st->bw_lpc2, sw, st->subframeSize, st->lpcSize, mem);
+
+#if 0
+         /*for (i=0;i<st->lpcSize;i++)
             mem[i]=st->mem_sp[i];
          residue_mem(exc, st->bw_lpc1, res, st->subframeSize, st->lpcSize, mem);
          for (i=0;i<st->lpcSize;i++)
             mem[i]=st->mem_sw[i];
-         syn_filt_mem(res, st->bw_lpc2, res, st->subframeSize, st->lpcSize, mem);
+            syn_filt_mem(res, st->bw_lpc2, res, st->subframeSize, st->lpcSize, mem);*/
          
          /* Compute weighted signal */
          for (i=0;i<st->lpcSize;i++)
@@ -513,7 +524,8 @@ void sb_encode(void *state, float *in, SpeexBits *bits)
          for (i=0;i<st->lpcSize;i++)
             mem[i]=st->mem_sw[i];
          syn_filt_mem(sw, st->bw_lpc2, sw, st->subframeSize, st->lpcSize, mem);
-         
+#endif
+
          /* Compute target signal */
          for (i=0;i<st->subframeSize;i++)
             target[i]=sw[i]-res[i];
@@ -572,11 +584,13 @@ void sb_encode(void *state, float *in, SpeexBits *bits)
          for (i=0;i<st->lpcSize;i++)
             mem[i]=st->mem_sp[i];
          /* Final signal synthesis from excitation */
-         syn_filt_mem(exc, st->interp_qlpc, sp, st->subframeSize, st->lpcSize, st->mem_sp);
+         iir_mem2(exc, st->interp_qlpc, sp, st->subframeSize, st->lpcSize, st->mem_sp);
          
          /* Compute weighted signal again, from synthesized speech (not sure it's the right thing) */
-         residue_mem(sp, st->bw_lpc1, sw, st->subframeSize, st->lpcSize, mem);
+         /*residue_mem(sp, st->bw_lpc1, sw, st->subframeSize, st->lpcSize, mem);
          syn_filt_mem(sw, st->bw_lpc2, sw, st->subframeSize, st->lpcSize, st->mem_sw);
+         */
+         filter_mem2(sp, st->bw_lpc1, st->bw_lpc2, sw, st->subframeSize, st->lpcSize, st->mem_sw);
 #endif
       
       
@@ -695,7 +709,7 @@ static void sb_decode_lost(SBDecState *st, float *out)
    st->first=1;
    
    /* Final signal synthesis from excitation */
-   syn_filt_mem(st->exc, st->interp_qlpc, st->high, st->subframeSize, st->lpcSize, st->mem_sp);
+   iir_mem2(st->exc, st->interp_qlpc, st->high, st->subframeSize, st->lpcSize, st->mem_sp);
    
    /* Up-sample coded low-band and high-band*/
    for (i=0;i<st->frame_size;i++)
@@ -762,7 +776,7 @@ int sb_decode(void *state, SpeexBits *bits, float *out)
       st->first=1;
 
       /* Final signal synthesis from excitation */
-      syn_filt_mem(st->exc, st->interp_qlpc, st->high, st->subframeSize, st->lpcSize, st->mem_sp);
+      iir_mem2(st->exc, st->interp_qlpc, st->high, st->subframeSize, st->lpcSize, st->mem_sp);
 
       /* Up-sample coded low-band and high-band*/
       for (i=0;i<st->frame_size;i++)
@@ -879,7 +893,7 @@ int sb_decode(void *state, SpeexBits *bits, float *out)
          }
 
       }
-      syn_filt_mem(exc, st->interp_qlpc, sp, st->subframeSize, st->lpcSize, st->mem_sp);
+      iir_mem2(exc, st->interp_qlpc, sp, st->subframeSize, st->lpcSize, st->mem_sp);
 
    }