enc_lpc.c

ffmpeg源码分析

 *    a              I: LP filter coefficients
 *    ap             O: weighted LP filter coefficients
 *    gamma          I: weighting factor
 *    m              I: order of LP filter
 *
 * Function:
 *    Weighting of LP filter coefficients, ap[i] = a[i] * (gamma^i).
 *
 * Returns:
 *    void
 */
void E_LPC_a_weight(Float32 *a, Float32 *ap, Float32 gamma, Word32 m)
{
   Float32 f;
   Word32 i;

   ap[0] = a[0];
   f = gamma;

   for (i = 1; i <= m; i++)
   {
      ap[i] = f*a[i];
      f *= gamma;
   }

   return;
}

/*
 * E_LPC_isf_2s3s_decode
 *
 * Parameters:
 *    indice            I: quantisation indices
 *    isf_q             O: quantised ISFs in the cosine domain
 *    past_isfq       I/O: past ISF quantizer
 *
 * Function:
 *    Decoding of ISF parameters.
 *
 * Returns:
 *    void
 */
static void E_LPC_isf_2s3s_decode(Word32 *indice, Word16 *isf_q,
                                  Word16 *past_isfq)
{
   Word32 i;
   Word16 tmp;

   for(i = 0; i < 9; i++)
   {
      isf_q[i] = (Word16)((E_ROM_dico1_isf[indice[0] * 9 + i] * 2.56F) + 0.5F);
   }

   for(i = 0; i < 7; i++)
   {
      isf_q[i + 9] =
         (Word16)((E_ROM_dico2_isf[indice[1] * 7 + i] * 2.56F) + 0.5F);
   }

   for(i = 0; i < 5; i++)
   {
      isf_q[i] = (Word16)(isf_q[i] +
         (Word16)((E_ROM_dico21_isf_36b[indice[2] * 5 + i] * 2.56F) + 0.5F));
   }

   for(i = 0; i < 4; i++)
   {
      isf_q[i + 5] = (Word16)(isf_q[i + 5] +
         (Word32)((E_ROM_dico22_isf_36b[indice[3] * 4 + i] * 2.56F) + 0.5F));
   }

   for(i = 0; i < 7; i++)
   {
      isf_q[i + 9] = (Word16)(isf_q[i + 9] +
         (Word32)((E_ROM_dico23_isf_36b[indice[4] * 7 + i] * 2.56F) + 0.5F));
   }

   for(i = 0; i < ORDER; i++)
   {
      tmp = isf_q[i];
      isf_q[i] = (Word16)(tmp + E_ROM_mean_isf[i]);
      isf_q[i] = (Word16)(isf_q[i] + ((MU * past_isfq[i]) >> 15));
      past_isfq[i] = tmp;
   }

   E_LPC_isf_reorder(isf_q, ISF_GAP, ORDER);

   return;
}


/*
 * E_LPC_isf_2s5s_decode
 *
 * Parameters:
 *    indice            I: quantization indices
 *    isf_q             O: quantized ISFs in the cosine domain
 *    past_isfq       I/O: past ISF quantizer
 *    isfold            I: past quantized ISF
 *    isf_buf           I: isf buffer
 *    bfi               I: Bad frame indicator
 *    enc_dec           I:
 *
 * Function:
 *    Decoding of ISF parameters.
 *
 * Returns:
 *    void
 */
void E_LPC_isf_2s5s_decode(Word32 *indice, Word16 *isf_q, Word16 *past_isfq)
{
   Word32 i;
   Word16 tmp;

   for (i = 0; i < 9; i++)
   {
      isf_q[i] = (Word16)((E_ROM_dico1_isf[indice[0] * 9 + i] * 2.56F) + 0.5F);
   }

   for (i = 0; i < 7; i++)
   {
      isf_q[i + 9] =
         (Word16)((E_ROM_dico2_isf[indice[1] * 7 + i] * 2.56F) + 0.5F);
   }

   for (i = 0; i < 3; i++)
   {
      isf_q[i] = (Word16)(isf_q[i] +
         (Word32)((E_ROM_dico21_isf[indice[2] * 3 + i] * 2.56F) + 0.5F));
   }

   for (i = 0; i < 3; i++)
   {
      isf_q[i + 3] = (Word16)(isf_q[i + 3] +
         (Word32)((E_ROM_dico22_isf[indice[3] * 3 + i] * 2.56F) + 0.5F));
   }

   for (i = 0; i < 3; i++)
   {
      isf_q[i + 6] = (Word16)(isf_q[i + 6] +
         (Word32)((E_ROM_dico23_isf[indice[4] * 3 + i] * 2.56F) + 0.5F));
   }

   for (i = 0; i < 3; i++)
   {
      isf_q[i + 9] = (Word16)(isf_q[i + 9] +
         (Word32)((E_ROM_dico24_isf[indice[5] * 3 + i] * 2.56F) + 0.5F));
   }

   for (i = 0; i < 4; i++)
   {
      isf_q[i + 12] = (Word16)(isf_q[i + 12] +
         (Word32)((E_ROM_dico25_isf[indice[6] * 4 + i] * 2.56F) + 0.5F));
   }

   for (i = 0; i < ORDER; i++)
   {
      tmp = isf_q[i];
      isf_q[i] = (Word16)(tmp + E_ROM_mean_isf[i]);
      isf_q[i] = (Word16)(isf_q[i] + ((MU * past_isfq[i]) >> 15));
      past_isfq[i] = tmp;
   }

   E_LPC_isf_reorder(isf_q, ISF_GAP, ORDER);

   return;
}

/*
 * E_LPC_isf_isp_conversion
 *
 * Parameters:
 *    isp            O: (Q15) isp[m] (range: -1<=val<1)
 *    isf            I: (Q15) isf[m] normalized (range: 0.0 <= val <= 0.5)
 *    m              I: LPC order
 *
 * Function:
 *    Transformation isf to isp
 *
 *    ISP are immitance spectral pair in cosine domain (-1 to 1).
 *    ISF are immitance spectral pair in frequency domain (0 to 6400).
 * Returns:
 *    void
 */
void E_LPC_isf_isp_conversion(Word16 isf[], Word16 isp[], Word16 m)
{
   Word32 i, ind, offset, tmp;

   for (i = 0; i < m - 1; i++)
   {
      isp[i] = isf[i];
   }

   isp[m - 1] = (Word16)(isf[m - 1] << 1);

   for (i = 0; i < m; i++)
   {
      ind = isp[i] >> 7;         /* ind    = b7-b15 of isf[i] */
      offset = isp[i] & 0x007f;  /* offset = b0-b6  of isf[i] */

      /* isp[i] = table[ind]+ ((table[ind+1]-table[ind])*offset) / 128 */
      tmp = ((E_ROM_cos[ind + 1] - E_ROM_cos[ind]) * offset) << 1;
      isp[i] = (Word16)(E_ROM_cos[ind] + (tmp >> 8));
   }

   return;
}

/*
 * E_LPC_chebyshev
 *
 * Parameters:
 *    x           I: value of evaluation; x=cos(freq)
 *    f           I: coefficients of sum or diff polynomial
 *    n           I: order of polynomial
 *
 * Function:
 *    Evaluates the Chebyshev polynomial series
 *
 *    The polynomial order is n = m/2   (m is the prediction order)
 *    The polynomial is given by
 *    C(x) = f(0)T_n(x) + f(1)T_n-1(x) + ... +f(n-1)T_1(x) + f(n)/2
 *
 * Returns:
 *    the value of the polynomial C(x)
 */
static Float32 E_LPC_chebyshev(Float32 x, Float32 *f, Word32 n)
{
   Float32 b1, b2, b0, x2;
   Word32 i;                        /* for the special case of 10th order  */
                                    /*       filter (n=5)                  */
   x2 = 2.0F * x;                   /* x2 = 2.0*x;                         */
   b2 = f[0];                       /* b2 = f[0];                          */
   b1 = x2 * b2 + f[1];             /* b1 = x2*b2 + f[1];                  */

   for (i = 2; i < n; i++)
   {
      b0 = x2 * b1 - b2 + f[i];     /* b0 = x2 * b1 - 1. + f[2];           */
      b2 = b1;                      /* b2 = x2 * b0 - b1 + f[3];           */
      b1 = b0;                      /* b1 = x2 * b2 - b0 + f[4];           */
   }

   return (x * b1 - b2 + 0.5F * f[n]); /* return (x*b1 - b2 + 0.5*f[5]);   */
}
/*
 * E_LPC_isf_sub_vq
 *
 * Parameters:
 *    x            I/O: unquantised / quantised ISF
 *    dico           I: codebook
 *    dim            I: dimension of vector
 *    dico_size      I: codebook size
 *    distance       O: minimum distance
 *
 * Function:
 *    Quantization of a subvector of size 2 in Split-VQ of ISFs
 *
 * Returns:
 *    quantisation index
 */
Word16 E_LPC_isf_sub_vq(Float32 *x, const Float32 *E_ROM_dico, Word32 dim,
                        Word32 E_ROM_dico_size, Float32 *distance)
{
   Float32 dist_min, dist, temp;
   const Float32 *p_E_ROM_dico;
   Word32 i, j, index = 0;

   dist_min = 1.0e30f;
   p_E_ROM_dico = E_ROM_dico;

   for (i = 0; i < E_ROM_dico_size; i++)
   {
      dist = x[0] - *p_E_ROM_dico++;
      dist *= dist;

      for (j = 1; j < dim; j++)
      {
         temp = x[j] - *p_E_ROM_dico++;
         dist += temp * temp;
      }

      if (dist < dist_min)
      {
         dist_min = dist;
         index = i;
      }
   }

   *distance = dist_min;

   /* Reading the selected vector */
   memcpy(x, &E_ROM_dico[index * dim], dim * sizeof(Float32));

   return (Word16)index;
}

/*
 * E_LPC_lag_wind
 *
 * Parameters:
 *    r         I/O: autocorrelations vector
 *    m           I: window lenght
 *
 * Function:
 *    Lag windowing of the autocorrelations.
 *
 * Returns:
 *    void
 */
void E_LPC_lag_wind(Float32 r[], Word32 m)
{
   Word32 i;

   for (i = 0; i < m; i++)
   {
      r[i] *= E_ROM_lag_window[i];
   }

   return;
}

/*
 * E_LPC_lev_dur
 *
 * Parameters:
 *    r_h         I: vector of autocorrelations (msb)
 *    r_l         I: vector of autocorrelations (lsb)
 *    A           O: LP coefficients (a[0] = 1.0) (m = 16)
*     rc          O: reflection coefficients
 *    mem       I/O: static memory
 *
 * Function:
 *    Wiener-Levinson-Durbin algorithm to compute
 *    the LPC parameters from the autocorrelations of speech.
 *
 * Returns:
 *    void
 */
void E_LPC_lev_dur(Float32 *a, Float32 *r, Word32 m)
{
   Float32 buf[M];
   Float32 *rc;    /* reflection coefficients  0,...,m-1 */
   Float32 s, at, err;
   Word32 i, j, l;

   rc = &buf[0];

   rc[0] = (-r[1]) / r[0];
   a[0] = 1.0F;
   a[1] = rc[0];
   err = r[0] + r[1] * rc[0];

   for (i = 2; i <= m; i++)
   {
      s = 0.0F;

      for (j = 0; j < i; j++)
      {
         s += r[i - j] * a[j];
      }

      rc[i - 1]= (-s) / (err);

      for (j = 1; j <= (i >> 1); j++)
      {
         l = i - j;
         at = a[j] + rc[i - 1] * a[l];
         a[l] += rc[i - 1] * a[j];
         a[j] = at;
      }

      a[i] = rc[i - 1];
      err += rc[i - 1] * s;

      if (err <= 0.0F)
      {
         err = 0.01F;
      }
   }

   return;
}

/*
 * E_LPC_a_isp_conversion
 *
 * Parameters:
 *    a           I: LP filter coefficients
 *    isp         O: Immittance spectral pairs
 *    old_isp     I: ISP vector from past frame
 *
 * Function:
 *    Compute the ISPs from the LPC coefficients a[] using Chebyshev
 *    polynomials. The found ISPs are in the cosine domain with values
 *    in the range from 1 down to -1.
 *    The table E_ROM_grid[] contains the polongs (in the cosine domain) at
 *    which the polynomials are evaluated.
 *
 *    The ISPs are the roots of the two polynomials F1(z) and F2(z)
 *    defined as
 *               F1(z) = A(z) + z^-m A(z^-1)
 *    and        F2(z) = A(z) - z^-m A(z^-1)
 *
 *    for a even order m=2n, F1(z) has 5 conjugate roots on the unit circle
 *    and F2(z) has 4 conjugate roots on the unit circle in addition to two
 *    roots at 0 and pi.
 *
 *    For a 10th order LP analysis, F1(z) and F2(z) can be written as
 *
 *    F1(z) = (1 + a[10])   PRODUCT  (1 - 2 cos(w_i) z^-1 + z^-2 )
 *                       i=0,2,4,6,8
 *
 *    F2(z) = (1 - a[10]) (1 - z^-2) PRODUCT  (1 - 2 cos(w_i) z^-1 + z^-2 )
 *                                  i=1,3,5,7
 *
 *    The ISPs are the M-1 frequencies w_i, i=0...M-2 plus the last
 *    predictor coefficient a[M].
 *
 * Returns: