dec_lpc.c

ffmpeg源码分析

         isf_q[i + 5] =
            (Word16)(isf_q[i + 5] + D_ROM_dico22_isf_36b[indice[3] * 4 + i]);
      }

      for(i = 0; i < 7; i++)
      {
         isf_q[i + 9] =
            (Word16)(isf_q[i + 9] + D_ROM_dico23_isf_36b[indice[4] * 7 + i]);
      }

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

      for(i = 0; i < M; i++)
      {
         for(j = (L_MEANBUF - 1); j > 0; j--)
         {
            isf_buf[j * M + i] = isf_buf[(j - 1) * M + i];
         }
         isf_buf[i] = isf_q[i];
      }

   }
   else
   {   /* bad frame */

      for(i = 0; i < M; i++)
      {
         L_tmp = D_ROM_mean_isf[i];

         for(j = 0; j < L_MEANBUF; j++)
         {
            L_tmp = L_tmp + isf_buf[j * M + i];
         }
         ref_isf[i] = (L_tmp + 0x1) >> 2;
      }

      /* use the past ISFs slightly shifted towards their mean */
      for(i = 0; i < ORDER; i++)
      {
         isf_q[i] = (Word16)((((ALPHA * isfold[i]) >> 15) +
            ((ONE_ALPHA * ref_isf[i]) >> 15)));
      }

      /* estimate past quantized residual to be used in next frame */
      for(i = 0; i < ORDER; i++)
      {
         /* predicted ISF */
         L_tmp = ref_isf[i] + ((past_isfq[i] * MU) >> 15);
         /* past_isfq[i] *= 0.5 */
         past_isfq[i] = (Word16)((isf_q[i] - L_tmp) >> 1);
      }
   }

   D_LPC_isf_reorder(isf_q, ISF_GAP, ORDER);

   return;
}


/*
 * D_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           O: isf buffer
 *    bfi               I: Bad frame indicator
 *
 * Function:
 *    Decoding of ISF parameters.
 *
 * Returns:
 *    void
 */
void D_LPC_isf_2s5s_decode(Word16 *indice, Word16 *isf_q, Word16 *past_isfq,
                           Word16 *isfold, Word16 *isf_buf, Word16 bfi)
{
   Word32 ref_isf[M];
   Word32 i, j, L_tmp;
   Word16 tmp;

   if(bfi == 0) /* Good frame */
   {
      for(i = 0; i < 9; i++)
      {
         isf_q[i] = D_ROM_dico1_isf[indice[0] * 9 + i];
      }

      for(i = 0; i < 7; i++)
      {
         isf_q[i + 9] = D_ROM_dico2_isf[indice[1] * 7 + i];
      }

      for(i = 0; i < 3; i++)
      {
         isf_q[i] = (Word16)(isf_q[i] + D_ROM_dico21_isf[indice[2] * 3 + i]);
      }

      for(i = 0; i < 3; i++)
      {
         isf_q[i + 3] =
            (Word16)(isf_q[i + 3] + D_ROM_dico22_isf[indice[3] * 3 + i]);
      }

      for(i = 0; i < 3; i++)
      {
         isf_q[i + 6] =
            (Word16)(isf_q[i + 6] + D_ROM_dico23_isf[indice[4] * 3 + i]);
      }

      for(i = 0; i < 3; i++)
      {
         isf_q[i + 9] =
            (Word16)(isf_q[i + 9] + D_ROM_dico24_isf[indice[5] * 3 + i]);
      }

      for(i = 0; i < 4; i++)
      {
         isf_q[i + 12] =
            (Word16)(isf_q[i + 12] + D_ROM_dico25_isf[indice[6] * 4 + i]);
      }

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


      for(i = 0; i < M; i++)
      {
         for(j = (L_MEANBUF - 1); j > 0; j--)
         {
            isf_buf[j * M + i] = isf_buf[(j - 1) * M + i];
         }
         isf_buf[i] = isf_q[i];
      }

   }
   else
   {   /* bad frame */

      for(i = 0; i < M; i++)
      {
         L_tmp = D_ROM_mean_isf[i];

         for(j = 0; j < L_MEANBUF; j++)
         {
            L_tmp = L_tmp + isf_buf[j * M + i];
         }

         ref_isf[i] = (L_tmp + 0x1) >> 2;
      }

      /* use the past ISFs slightly shifted towards their mean */
      for(i = 0; i < ORDER; i++)
      {
         isf_q[i] = (Word16)(((ALPHA * isfold[i]) >> 15) +
            ((ONE_ALPHA * ref_isf[i]) >> 15));
      }

      /* estimate past quantized residual to be used in next frame */
      for(i = 0; i < ORDER; i++)
      {
         /* predicted ISF */
         L_tmp = ref_isf[i] + ((past_isfq[i] * MU) >> 15);
         /* past_isfq[i] *= 0.5 */
         past_isfq[i] = (Word16)((isf_q[i] - L_tmp) >> 1);
      }
   }

   D_LPC_isf_reorder(isf_q, ISF_GAP, ORDER);

   return;
}


/*
 * D_LPC_int_isp_find
 *
 * Parameters:
 *    isp_old           I: isps from past frame
 *    isp_new           I: isps from present frame
 *    frac              I: (Q15) fraction for 3 first subfr
 *    Az                O: LP coefficients in 4 subframes
 *
 * Function:
 *    Find the interpolated ISP parameters for all subframes.
 *
 * Returns:
 *    void
 */
void D_LPC_int_isp_find(Word16 isp_old[], Word16 isp_new[],
                        const Word16 frac[], Word16 Az[])
{
   Word32 tmp, i, k, fac_old, fac_new;
   Word16 isp[M];

   for(k = 0; k < 3; k++)
   {
      fac_new = frac[k];
      fac_old = (32767 - fac_new) + 1;   /* 1.0 - fac_new */

      for(i = 0; i < M; i++)
      {
         tmp = isp_old[i] * fac_old;
         tmp += isp_new[i] * fac_new;
         isp[i] = (Word16)((tmp + 0x4000) >> 15);
      }

      D_LPC_isp_a_conversion(isp, Az, M);
      Az += MP1;
   }

   /* 4th subframe: isp_new (frac=1.0) */
   D_LPC_isp_a_conversion(isp_new, Az, M);

   return;
}


/*
 * D_LPC_isf_extrapolation
 *
 * Parameters:
 *    HfIsf          I/O: ISF vector
 *
 * Function:
 *    Conversion of 16th-order 12.8kHz ISF vector
 *    into 20th-order 16kHz ISF vector
 *
 * Returns:
 *    void
 */
void D_LPC_isf_extrapolation(Word16 HfIsf[])
{
   Word32 IsfDiff[M - 2];
   Word32 IsfCorr[3];
   Word32 tmp, tmp2, tmp3, mean, i;
   Word32 MaxCorr, exp, exp2, coeff;
   Word16 hi, lo;

   HfIsf[M16k - 1] = HfIsf[M - 1];

   /* Difference vector */
   for(i = 1; i < M - 1; i++)
   {
      IsfDiff[i - 1] = HfIsf[i] - HfIsf[i - 1];
   }

   tmp = 0;

   /* Mean of difference vector */
   for(i = 3; i < (M - 1); i++)
   {
      tmp = tmp + (IsfDiff[i - 1] * INV_LENGTH);
   }

   mean = (tmp + 0x4000) >> 15;
   IsfCorr[0] = 0;
   IsfCorr[1] = 0;
   IsfCorr[2] = 0;
   tmp = 0;

   for(i = 0; i < M - 2; i++)
   {
      if(IsfDiff[i] > tmp)
      {
         tmp = IsfDiff[i];
      }
   }

   exp = D_UTIL_norm_s((Word16)tmp);

   for(i = 0; i < M - 2; i++)
   {
      IsfDiff[i] = IsfDiff[i] << exp;
   }

   mean = mean << exp;

   for(i = 7; i < M - 2; i++)
   {
      tmp2 = IsfDiff[i] - mean;
      tmp3 = IsfDiff[i - 2] - mean;
      tmp = (tmp2 * tmp3) << 1;
      D_UTIL_l_extract(tmp, &hi, &lo);
      tmp = D_UTIL_mpy_32(hi, lo, hi, lo);
      IsfCorr[0] = (IsfCorr[0] + tmp);
   }

   for(i = 7; i < M - 2; i++)
   {
      tmp2 = IsfDiff[i] - mean;
      tmp3 = IsfDiff[i - 3] - mean;
      tmp = (tmp2 * tmp3) << 1;
      D_UTIL_l_extract(tmp, &hi, &lo);
      tmp = D_UTIL_mpy_32(hi, lo, hi, lo);
      IsfCorr[1] = (IsfCorr[1] + tmp);
   }

   for(i = 7; i < M - 2; i++)
   {
      tmp2 = IsfDiff[i] - mean;
      tmp3 = IsfDiff[i - 4] - mean;
      tmp = (tmp2 * tmp3) << 1;
      D_UTIL_l_extract(tmp, &hi, &lo);
      tmp = D_UTIL_mpy_32(hi, lo, hi, lo);
      IsfCorr[2] = (IsfCorr[2] + tmp);
   }

   if(IsfCorr[0] > IsfCorr[1])
   {
      MaxCorr = 0;
   }
   else
   {
      MaxCorr = 1;
   }

   if(IsfCorr[2] > IsfCorr[MaxCorr])
   {
      MaxCorr = 2;
   }

   MaxCorr = MaxCorr + 1;   /* Maximum correlation of difference vector */

   for(i = M - 1; i < (M16k - 1); i++)
   {
      tmp = (HfIsf[i - 1 - MaxCorr] - HfIsf[i - 2 - MaxCorr]);
      HfIsf[i] = (Word16)(HfIsf[i - 1] + tmp);
   }

   /* tmp=7965+(HfIsf[2]-HfIsf[3]-HfIsf[4])/6; */
   tmp = HfIsf[4] + HfIsf[3];
   tmp = HfIsf[2] - tmp;
   tmp = (tmp * 5461) >> 15;
   tmp = tmp + 20390;

   if(tmp > 19456)
   {   /* Maximum value of ISF should be at most 7600 Hz */
      tmp = 19456;
   }

   tmp = tmp - HfIsf[M - 2];
   tmp2 = HfIsf[M16k - 2] - HfIsf[M - 2];
   exp2 = D_UTIL_norm_s((Word16)tmp2);
   exp = D_UTIL_norm_s((Word16)tmp);
   exp = exp - 1;
   tmp = tmp << exp;
   tmp2 = tmp2 << exp2;
   coeff = (tmp << 15) / tmp2;   /* Coefficient for stretching the ISF vector */
   exp = exp2 - exp;

   if(exp >= 0)
   {
      for(i = M - 1; i < M16k - 1; i++)
      {
         tmp = ((HfIsf[i] - HfIsf[i - 1]) * coeff) >> 15;
         IsfDiff[i - (M - 1)] = tmp << exp;
      }
   }
   else
   {
      exp = 15 - exp;

      for(i = M - 1; i < M16k - 1; i++)
      {
         IsfDiff[i - (M - 1)] = ((HfIsf[i] - HfIsf[i - 1]) * coeff) >> exp;
      }
   }

   for(i = M; i < (M16k - 1); i++)
   {
      /* The difference between ISF(n) and ISF(n-2) should be at least 500 Hz */
      tmp = ((IsfDiff[i - (M - 1)] + IsfDiff[i - M]) - 1280);

      if(tmp < 0)
      {
         if(IsfDiff[i - (M - 1)] > IsfDiff[i - M])
         {
            IsfDiff[i - M] = (1280 - IsfDiff[i - (M - 1)]);
         }
         else
         {
            IsfDiff[i - (M - 1)] = (1280 - IsfDiff[i - M]);
         }
      }
   }

   for(i = M - 1; i < M16k - 1; i++)
   {
      HfIsf[i] = (Word16)(HfIsf[i - 1] + IsfDiff[i - (M - 1)]);
   }

   for(i = 0; i < M16k - 1; i++)
   {
      HfIsf[i] = (Word16)((HfIsf[i] * 13107) >> 14);
      /* Scale the ISF vector correctly for 16000 kHz */
   }

   D_LPC_isf_isp_conversion(HfIsf, HfIsf, M16k);

   return;
}