开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 语音压缩 > 查看源码
PWF.C
资源名称：G711-729.rar　[点击查看]
上传用户：meifeng08
上传日期：2013-06-18
资源大小：5304k
文件大小：6k
源码类别：

语音压缩

开发平台：

C/C++

PWF.C：源码内容
  1. /* Version 3.3    Last modified: December 26, 1995 */
  3. #include "typedef.h"
  4. #include "basic_op.h"
  5. #include "ld8k.h"
  7. static Word16     smooth = 1;
  8. static Word16     LarOld[2] = {0, 0};
  10. /************************************************************************/
  11. /*                                                                      */
  12. /*   ADAPTIVE BANDWIDTH EXPANSION FOR THE PERCEPTUAL WEIGHTING FILTER   */
  13. /*                                                                      */
  14. /*                 W(z) = A (z/gamma1) / A(z/gamma2)                    */
  15. /*                                                                      */
  16. /************************************************************************/
  18. void perc_var (
  19.   Word16 *gamma1, /* Bandwidth expansion parameter */
  20.   Word16 *gamma2, /* Bandwidth expansion parameter */
  21.   Word16 *LsfInt, /* Interpolated LSP vector : 1st subframe */
  22.   Word16 *LsfNew, /* New LSP vector : 2nd subframe */
  23.   Word16 *r_c     /* Reflection coefficients */
  24. )
  25. {
  27.   Word32   L_temp;
  28.   Word16   cur_rc;                    /* Q11 */
  29.   Word16   Lar[4];                    /* Q11 */
  30.   Word16  *LarNew;                    /* Q11 */
  31.   Word16  *Lsf;                       /* Q15 */
  32.   Word16   CritLar0, CritLar1;        /* Q11 */
  33.   Word16   temp;
  34.   Word16   d_min;                     /* Q10 */
  35.   Word16   i, k;
  39.   for (k=0; k<M; k++) {
  40.     LsfInt[k] = shl(LsfInt[k], 1);
  41.     LsfNew[k] = shl(LsfNew[k], 1);
  42.   }
  45.   LarNew = &Lar[2];
  46.   /* ---------------------------------------- */
  47.   /* Reflection coefficients ---> Lar         */
  48.   /* Lar(i) = log10( (1+rc) / (1-rc) )        */
  49.   /* Approximated by                          */
  50.   /* x <= SEG1            y = x               */
  51.   /* SEG1 < x <= SEG2     y = A1 x - B1_L     */
  52.   /* SEG2 < x <= SEG3     y = A2 x - B2_L     */
  53.   /* x > SEG3             y = A3 x - B3_L     */
  54.   /* ---------------------------------------- */
  55.   for (i=0; i<2; i++) {
  57.     cur_rc = abs_s(r_c[i]);
  58.     cur_rc = shr(cur_rc, 4);
  60.     if (sub(cur_rc ,SEG1)<= 0) {
  61.         LarNew[i] = cur_rc;
  62.     }
  63.     else {
  64.       if (sub(cur_rc,SEG2)<= 0) {
  65.         cur_rc = shr(cur_rc, 1);
  66.         L_temp = L_mult(cur_rc, A1);
  67.         L_temp = L_sub(L_temp, L_B1);
  68.         L_temp = L_shr(L_temp, 11);
  69.         LarNew[i] = extract_l(L_temp);
  70.       }
  71.       else {
  72.         if (sub(cur_rc ,SEG3)<= 0) {
  73.           cur_rc = shr(cur_rc, 1);
  74.           L_temp = L_mult(cur_rc, A2);
  75.           L_temp = L_sub(L_temp, L_B2);
  76.           L_temp = L_shr(L_temp, 11);
  77.           LarNew[i] = extract_l(L_temp);
  78.         }
  79.         else {
  80.           cur_rc = shr(cur_rc, 1);
  81.           L_temp = L_mult(cur_rc, A3);
  82.           L_temp = L_sub(L_temp, L_B3);
  83.           L_temp = L_shr(L_temp, 11);
  84.           LarNew[i] = extract_l(L_temp);
  85.         }
  86.       }
  87.     }
  88.     if (r_c[i] < 0) {
  89.         LarNew[i] = sub(0, LarNew[i]);
  91.     }
  92.   }
  94.   /* Interpolation of Lar for the 1st subframe */
  96.   temp = add(LarNew[0], LarOld[0]);
  97.   Lar[0] = shr(temp, 1);
  98.   LarOld[0] = LarNew[0];
  99.   temp = add(LarNew[1], LarOld[1]);
  100.   Lar[1] = shr(temp, 1);
  101.   LarOld[1] = LarNew[1];
  103.   for (k=0; k<2; k++) { /* LOOP : gamma2 for 1st to 2nd subframes */
  105.       /* ---------------------------------------------------------- */
  106.       /* First criterion based on the first two Lars                */
  107.       /* smooth == 1  ==>  gamma2 can vary from 0.4 to 0.7          */
  108.       /* smooth == 0  ==>  gamma2 is set to 0.6                     */
  109.       /*                                                            */
  110.       /* Double threshold + hysteresis :                            */
  111.       /* if smooth = 1                                              */
  112.       /*  if (CritLar0 < THRESH_L1) and (CritLar1 > THRESH_H1)      */
  113.       /*                                                 smooth = 0 */
  114.       /* if smooth = 0                                              */
  115.       /*  if (CritLar0 > THRESH_L2) or (CritLar1 < THRESH_H2)       */
  116.       /*                                                 smooth = 1 */
  117.       /* ---------------------------------------------------------- */
  119.       CritLar0 = Lar[2*k];
  120.       CritLar1 = Lar[2*k+1];
  122.       if (smooth != 0) {
  123.         if ((sub(CritLar0,THRESH_L1)<0)&&( sub(CritLar1,THRESH_H1)>0)) {
  124.             smooth = 0;
  125.         }
  126.       }
  127.       else {
  128.         if ( (sub(CritLar0 ,THRESH_L2)>0) || (sub(CritLar1,THRESH_H2) <0) ) {
  129.             smooth = 1;
  130.         }
  132.       }
  134.     if (smooth == 0) {
  135.       /* ------------------------------------------------------ */
  136.       /* Second criterion based on the minimum distance between */
  137.       /*                two successives LSPs                    */
  138.       /*                                                        */
  139.       /*           gamma2[k] = -6.0 * pi * d_min + 1.0          */
  140.       /*                                                        */
  141.       /*       with Lsfs normalized range 0.0 <= val <= 1.0     */
  142.       /* ------------------------------------------------------ */
  143.       gamma1[k] = GAMMA1_0;
  144.       if (k == 0) {
  145.         Lsf = LsfInt;
  146.       }
  147.       else {
  148.         Lsf = LsfNew;
  149.       }
  150.       d_min = sub(Lsf[1], Lsf[0]);
  151.       for (i=1; i<M-1; i++) {
  152.         temp = sub(Lsf[i+1],Lsf[i]);
  153.         if (sub(temp,d_min)<0) {
  154.             d_min = temp;
  155.         }
  156.       }
  157.       temp = mult(ALPHA, d_min);
  158.       temp = sub(BETA, temp);
  159.       temp = shl(temp, 5);
  160.       gamma2[k] = temp;
  162.       if (sub(gamma2[k] , GAMMA2_0_H)>0) {
  163.         gamma2[k] = GAMMA2_0_H;
  164.       }
  165.       if (sub(gamma2[k] ,GAMMA2_0_L)<0) {
  166.         gamma2[k] = GAMMA2_0_L;
  167.       }
  169.     }
  170.     else {
  171.       gamma1[k] = GAMMA1_1;
  172.       gamma2[k] = GAMMA2_1;
  173.     }
  174.   }
  175.   return;
  176. }