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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 语音压缩 > 查看源码
vq_lib.c
资源名称：melp.rar　[点击查看]
上传用户：csczyc
上传日期：2021-02-19
资源大小：1051k
文件大小：21k
源码类别：

语音压缩

开发平台：

C/C++

vq_lib.c：源码内容
  1. #include <stdio.h>
  2. #include "spbstd.h"
  3. #include "mathhalf.h"
  4. #include "wmops.h"
  5. #include "mat.h"
  6. #include "math_lib.h"
  7. #include "lpc.h"
  8. #include "vq.h"
  9. #include "constant.h"
  11. /* VQ_LSPW- compute LSP weighting vector-
  13.     Atal's method:
  14.         From Atal and Paliwal (ICASSP 1991)
  15.         (Note: Paliwal and Atal used w(k)^2(u(k)-u_hat(k))^2,
  16.          and we use w(k)(u(k)-u_hat(k))^2 so our weights are different
  17.          but the method (i.e. the weighted MSE) is the same.
  19.                 */
  20. /* Q values:
  21.    w is Q11
  22.    lsp is Q15
  23.    a is Q12 */
  25. Shortword *vq_lspw(Shortword *w, Shortword *lsp, Shortword *a, 
  26.    Shortword p)
  27. {
  28.     Shortword j;
  29.     Longword L_temp;
  31. Longword L_temp1;
  32.     
  33.     for(j = 0; j < 8; j++)
  34.       {
  35. L_temp = lpc_aejw(a,lsp[j],p);    /* L_temp in Q19 */
  36. w[j] = L_pow_fxp(L_temp,(Shortword)XN03_Q15,19,11);
  38.       }
  40. j = 8;
  41.   /* w[j] = mult(w[j], (Shortword)X064_Q15); */
  42.    L_temp1 = _smpy(w[j], (Shortword)X064_Q15);
  43.    w[j] = (Shortword) (0x0000ffffL & (L_temp1 >> 16));
  45.  j = 9;
  46.  /*  w[j] = mult(w[j], (Shortword)X016_Q15); */
  47.    L_temp1 = _smpy(w[j], (Shortword)X016_Q15);
  48.    w[j] = (Shortword) (0x0000ffffL & (L_temp1 >> 16));
  49.  
  51.     return(w);
  52. } /* VQ_LSPW */
  56. /*
  57.     VQ_MS4-
  58.         Tree search multi-stage VQ encoder (optimized for speed
  59.         should be compatible with VQ_MS)
  61.     Synopsis: vq_ms4(cb,u,u_est,levels,ma,stages,p,w,u_hat,a_indices)
  62.         Input:
  63.             cb- one dimensional linear codebook array (codebook is structured 
  64.                 as [stages][levels for each stage][p])
  65.             u- dimension p, the parameters to be encoded (u[0..p-1])
  66.             u_est- dimension p, the estimated parameters or mean (if NULL, assume
  67.                estimate is the all zero vector) (u_est[0..p-1])
  68.             levels- the number of levels at each stage (levels[0..stages-1])
  69.             ma- the tree search size (keep ma candidates from one stage to the
  70.                next)
  71.             stages- the number of stages of msvq
  72.             p- the predictor order
  73.             w- the weighting vector (w[0..p-1])
  74.             max_inner- the maximum number of times the swapping procedure
  75.                        in the inner loop can be executed
  76.         Output:
  77.             u_hat-   the reconstruction vector (if non null)
  78.             a_indices- the codebook indices (for each stage) a_indices[0..stages-1]
  79.         Parameters:
  81. */
  83. #define P_SWAP(x,y,type) do{type u__p;u__p = x;x = y;y = u__p;}while(0)
  85. /* cb is Q17
  86.    u is Q15
  87.    u_est is Q15
  88.    w is Q11
  89.    u_hat is Q15 */
  91. Shortword vq_ms4(Shortword *cb, Shortword *u, Shortword *u_est, 
  92.  Shortword *levels, Shortword ma, Shortword stages, 
  93.  Shortword p, Shortword *w, Shortword *u_hat, 
  94.  Shortword *a_indices, Shortword max_inner)
  95. {
  96.     Shortword tmp,*u_tmp,*uhatw,uhatw_sq;
  97.     Shortword d_cj,d_opt;
  98.     Shortword *d,*p_d,*n_d,*p_distortion,*cb_currentstage,*cbp, *cb_table;
  99.     Shortword *errors,*p_errors,*n_errors,*p_e;
  100.     Shortword i,j,m,s,c,p_max,inner_counter;
  101.     Shortword *indices,*p_indices,*n_indices;
  102.     Shortword *parents,*p_parents,*n_parents;
  103.     Shortword *tmp_p_e;
  105.     Shortword temp;
  106.     Longword L_temp,L_temp1;
  108. Longword L_temp2;
  109. Shortword temp1;
  110.     
  111.     /* make sure weights don't get too big */
  112. #define MAXWT  4096           /* w[i] < 2.0 to avoid saturation */
  113. #define MAXWT2 (MAXWT*2)
  114. #define MAXWT4 (MAXWT*4)
  115.     j = 0;  //  data_move();mark del
  116.     for (i = 0; i < p; i++) {
  117.       if (w[i] > MAXWT4) {
  118.         /* increment complexity for if statement */
  119.      //   compare_nonzero();mark del
  120. j = 3;  //  data_move();mark del
  121. break;
  122.       }
  123.       else if (w[i] > MAXWT2) {
  124.         /* increment complexity for if statement */
  125.     //    compare_nonzero();mark del
  126. j = 2;  //  data_move();mark del
  127.       }
  128.       else if (w[i] > MAXWT) {
  129.         /* increment complexity for if statement */
  130.        // compare_nonzero();mark del
  131. /* increment complexity for if statement */
  132.      //   compare_zero();mark del
  133. if (j == 0) {
  134.   j = 1;  //  data_move();mark del
  135. }
  136.       }
  137.     }
  138.     for (i = 0; i < p; i++) {
  139.       /* w[i] = shr(w[i],j); //   data_move();mark del */
  140.    L_temp2 = _shr2((Longword)w[i],j);
  141.    w[i] = (Shortword) (0x0000ffffL & L_temp2);
  142.     }
  145.     /* allocate memory for the current node and
  146.        parent node (thus, the factors of two everywhere)
  147.        The parents and current nodes are allocated contiguously */
  148.     MEM_ALLOC(MALLOC,indices,2*ma*stages,Shortword);
  149.     MEM_ALLOC(MALLOC,errors,2*ma*p,Shortword);
  150.     MEM_ALLOC(MALLOC,uhatw,p,Shortword);
  151.     MEM_ALLOC(MALLOC,d,2*ma,Shortword);
  152.     MEM_ALLOC(MALLOC,parents,2*ma,Shortword);
  153.     MEM_ALLOC(MALLOC,tmp_p_e,ma*p,Shortword);
  154.     
  155.     /* initialize memory */
  156.     v_zap(indices,(Shortword)(2*stages*ma));
  157.     v_zap(parents,(Shortword)(2*ma));
  159.     
  160.     /* initialize inner loop counter */
  161.     inner_counter = 0; // data_move();mark del
  162.     
  163.     /* set up memory */
  164.     p_indices = &indices[0]; // data_move();mark del
  165.     n_indices = &indices[ma*stages]; // data_move();mark del
  166.     p_errors = &errors[0]; // data_move();mark del
  167.     n_errors = &errors[ma*p];//  data_move();mark del
  168.     p_d = &d[0]; // data_move();mark del
  169.     n_d = &d[ma]; // data_move();mark del
  170.     p_parents = &parents[0]; // data_move();mark del
  171.     n_parents = &parents[ma];//  data_move();mark del
  172.     
  173.     /* u_tmp is the input vector (i.e. if u_est is non-null, it
  174.        is subtracted off) */
  175.     MEM_ALLOC(MALLOC,u_tmp,p+1,Shortword);
  176.     /* u_tmp is Q15 */
  177.     (void)v_equ(u_tmp,u,p);
  178.     if (u_est)
  179.       (void)v_sub(u_tmp,u_est,p);
  181.     /* change u_tmp from Q15 to Q17 */
  182.     for (j=0; j<p; j++)
  183.       u_tmp[j] = shl_a(u_tmp[j], 2); // data_move();mark del
  185.     /* L_temp is Q31 */
  186.     L_temp = 0; // data_move();mark del
  187.     for(j = 0 ; j < p; j++) {
  188.      /*  temp = mult(u_tmp[j],w[j]);     temp = Q13 */ 
  189. /*       L_temp = L_mac(L_temp,temp,u_tmp[j]);           */
  190.         L_temp2 =_smpy(u_tmp[j],w[j]);
  191. temp = (Shortword) (0x0000ffffL & (L_temp2 >> 16));
  192.         L_temp = _sadd(L_temp,_smpy(temp,u_tmp[j]));
  193.     }
  195.     /* tmp in Q15 */
  196. /*     tmp = extract_h(L_temp); */
  197.       tmp = (Shortword) (0x0000ffffL & (L_temp >> 16));
  199.     /* set up inital error vectors (i.e. error vectors = u_tmp) */
  200.     for(c=0; c < ma; c++)
  201.     {
  202. /* n_errors is Q17
  203.    n_d is Q15 */
  204. (void)v_equ(&n_errors[c*p],u_tmp,p);
  205. n_d[c] = tmp;  // data_move();mark del
  206.     }
  208.     /* no longer need memory so free it here */
  209.     MEM_FREE(FREE,u_tmp);
  211.     /* codebook pointer is set to point to first stage */
  212.     cbp = cb;
  214.     /* set m to 1 for the first stage
  215.        and loop over all stages */
  217.     for(m=1,s=0; s < stages; s++)
  218.     {
  219.         /* Save the pointer to the beginning of the
  220.            current stage.  Note: cbp is only incremented in
  221.            one spot, and it is incremented all the way through
  222.            all the stages. */
  223.         cb_currentstage = cbp;
  225.         /* set up pointers to the parent and current nodes */
  226.         P_SWAP(p_indices,n_indices,Shortword*);
  227.         P_SWAP(p_parents,n_parents,Shortword*);
  228. P_SWAP(p_errors,n_errors,Shortword*);
  229. P_SWAP(p_d,n_d,Shortword*);
  231.         /* p_max is the pointer to the maximum distortion
  232.            node over all candidates.  The so-called worst
  233.            of the best. */
  234.         p_max = 0; // data_move();mark del
  236. /* store errors in Q15 in tmp_p_e */
  237. for (i = 0; i < m*p; i++) {
  238.  /*  tmp_p_e[i] = shr(p_errors[i],2); // data_move();mark del */
  239.    L_temp2 = _shr2((Longword)p_errors[i],2);
  240.        tmp_p_e[i] = (Shortword) (0x0000ffffL & L_temp2);
  241. }
  243.         /* set the distortions to a large value */
  244.         for(c=0; c < ma; c++) {
  245.     n_d[c] = SW_MAX; // data_move();mark del
  246. }
  247.         for(j=0; j < levels[s]; j++)
  248.         {
  249.             /* compute weighted codebook element, increment codebook pointer */
  250.     /* L_temp is Q31 */
  251.     L_temp = 0;  //  data_move();mark del
  252.     for(i=0 ; i < p; i++,cbp++)
  253.             {
  254.         /* Q17*Q11<<1 = Q29 */
  255.       /*   L_temp1 = L_mult(*cbp,w[i]); */
  256.      L_temp1 = _smpy(*cbp,w[i]);
  258. /* uhatw[i] = -2*tmp */
  259. /* uhatw is Q15 (shift 3 to take care of *2)*/
  260. /*  uhatw[i] = negate(extract_h(L_shl(L_temp1,3)));    */
  261.     L_temp2 = _sshl(L_temp1,3);
  262. temp1 = (Shortword)(0x0000ffff & (L_temp2 >> 16));
  263.         uhatw[i] = negate(temp1);
  265. /* tmp is now Q13 */
  266. /*  tmp = extract_h(L_temp1);           */
  267. /*  L_temp = L_mac(L_temp,*cbp,tmp);    */
  268.         tmp = (Shortword) (0x0000ffffL & (L_temp1 >> 16));
  269.         L_temp = _sadd(L_temp,_smpy(*cbp,tmp));
  270.             }
  271.     /* uhatw_sq is Q15 */
  272.     /* uhatw_sq = extract_h(L_temp); */
  273.           uhatw_sq = (Shortword) (0x0000ffffL & (L_temp >> 16)); 
  275.             /* p_e points to the error vectors and p_distortion
  276.                points to the node distortions.  Note: the error
  277.                vectors are contiguous in memory, as are the distortions.
  278.                Thus, the error vector for the 2nd node comes immediately
  279.                after the error for the first node.  (This saves on
  280.                repeated initializations) */
  281.     /* p_e is Q15 */
  282.     p_e = tmp_p_e;
  283.             p_distortion = p_d;
  284.     
  285.             /* iterate over all parent nodes */
  286.             for(c=0; c < m; c++)
  287.             {
  288. /* L_temp is Q31
  289.    p_distortion is same Q as n_d 
  290.    p_e is Q15 */
  291. /* L_temp = L_deposit_h(add(*p_distortion++,uhatw_sq)); */
  292.       L_temp2 = _sadd2(*p_distortion++,uhatw_sq);
  293.   temp1 = (Shortword) (0x0000ffffL & L_temp2);
  294.   L_temp = (Longword) temp1 << 16;
  295.                 for(i=0; i < p; i++) {
  296.   /* L_temp = L_mac(L_temp,*p_e++,uhatw[i]); */
  297.      L_temp = _sadd(L_temp,_smpy(*p_e++,uhatw[i]));
  298. }
  300. /* d_cj is Q15 */
  302. /*  d_cj = extract_h(L_temp);  */
  303.     d_cj = (Shortword) (0x0000ffffL & (L_temp >> 16));
  306.                 /* determine if d is less than the maximum candidate distortion                   i.e., is the distortion found better than the so-called
  307.                    worst of the best */
  308. /* increment complexity for if statement */
  309. // compare_nonzero();mark del
  310.                 if (d_cj <= n_d[p_max])
  311.                 {
  312.                     /* replace the worst with the values just found */
  313.     /* n_d is now a Q16 */
  314.     n_d[p_max] = d_cj; //   data_move();mark del
  316.                     /* i = add(shr(extract_l(L_mult(p_max,stages)),1),s); */
  317. L_temp2 = _smpy(p_max,stages);
  318. L_temp2 = _shr2(L_temp2,1);
  319. L_temp2 = _sadd2(L_temp2,(Longword)s);
  320. i = (Shortword) (0x0000ffffL & L_temp2);
  322.                     n_indices[i] = j;   //     data_move();mark del
  323.                     n_parents[p_max] = c;   // data_move();mark del
  325.                     /* want to limit the number of times the inner loop
  326.                        is entered (to reduce the *maximum* complexity) */
  327.     /* increment complexity for if statement */
  328. //     compare_nonzero();mark del
  329.                     if (inner_counter < max_inner)
  330.                     {
  331.                         /* inner_counter = add(inner_counter,1); */
  332. L_temp2 = _sadd2((Longword)inner_counter,(Longword)1);
  333. inner_counter = (Shortword) (0x0000ffffL & L_temp2);
  334. /* increment complexity for if statement */
  335. // compare_nonzero();mark del
  336.         if (inner_counter < max_inner)
  337. {
  338.                             p_max = 0;  //  data_move();mark del
  339.                             /* find the new maximum */
  340.             for(i=1; i < ma; i++)
  341.                             {
  342.         /* increment complexity for if statement */
  343.       //  compare_nonzero();mark del
  344.                                 if (n_d[i] > n_d[p_max])
  345.                                     p_max = i;  //  data_move();mark del
  346.             }
  347.         }
  348. else /* inner_counter == max_inner */
  349.                         {
  350.                                /* The inner loop counter now exceeds the
  351.                                maximum, and the inner loop will now not
  352.                                be entered.  Instead of quitting the search
  353.                                or doing something drastic, we simply keep
  354.                                track of the best candidate (rather than the
  355.                                M best) by setting p_max to equal the index
  356.                                of the minimum distortion
  357.                                i.e. only keep one candidate around
  358.                                 the MINIMUM distortion */
  359.             for(i=1; i < ma; i++)
  360.                             {
  361.         /* increment complexity for if statement */
  362.  //       compare_nonzero();mark del
  363.                                 if (n_d[i] < n_d[p_max])
  364.                                     p_max = i;  //  data_move();mark del
  365.             }
  366.         }
  367.     }
  368.                 }
  370.             } /* for c */
  371.         } /* for j */
  374.         /* compute the error vectors for each node */
  375.         for(c=0; c < ma; c++)
  376.         {
  377.             /* get the error from the parent node and subtract off
  378.                the codebook value */
  379.     (void)v_equ(&n_errors[c*p],&p_errors[n_parents[c]*p],p);
  380.     (void)v_sub(&n_errors[c*p],
  381. &cb_currentstage[n_indices[c*stages+s]*p],p);
  382.             /* get the indices that were used for the parent node */
  383.             (void)v_equ(&n_indices[c*stages],
  384. &p_indices[n_parents[c]*stages],s);
  385.         }
  387.         /* increment complexity for if statement */
  388.   //      compare_nonzero();  data_move();mark del
  389.         m = (m*levels[s] > ma) ? ma : m*levels[s];
  390.     } /* for s */
  393.     /* find the optimum candidate c */
  394.     for(i=1,c=0; i < ma; i++)
  395.     {
  396.         /* increment complexity for if statement */
  397. //        compare_nonzero();mark del
  398.         if (n_d[i] < n_d[c])
  399.     c = i;   // data_move();mark del
  400.     }
  402.     d_opt = n_d[c]; //   data_move();mark del
  403.     
  404.     if (a_indices)
  405.     {
  406.         (void)v_equ(a_indices,&n_indices[c*stages],stages);
  407.     }
  408.     if (u_hat)
  409.     {
  410.         if (u_est)
  411.     (void)v_equ(u_hat,u_est,p);
  412.         else
  413.     (void)v_zap(u_hat,p);
  415.         cb_currentstage = cb;
  416.         for(s=0; s < stages; s++)
  417.         {
  418.   cb_table = &cb_currentstage[n_indices[c*stages+s]*p];   
  419.   for (i=0; i<p; i++){
  420.    /*  u_hat[i] = add(u_hat[i], shr(cb_table[i],2));  // data_move();  mark del */
  421.        L_temp2 = _shr2((Longword)cb_table[i],2);
  422.        L_temp2 = _sadd2((Longword)u_hat[i],L_temp2);
  423.        u_hat[i] = (Shortword) (0x0000ffffL & L_temp2); 
  424.    }
  425.   cb_currentstage += levels[s]*p;
  426.         }
  427.     }
  429.     
  430.     MEM_FREE(FREE,parents);
  431.     MEM_FREE(FREE,d);
  432.     MEM_FREE(FREE,uhatw);
  433.     MEM_FREE(FREE,errors);
  434.     MEM_FREE(FREE,indices);
  435.     MEM_FREE(FREE,tmp_p_e);
  437.     return(d_opt);
  438. } /* vq_ms4 */
  440. /*
  441.     VQ_MSD2-
  442.         Tree search multi-stage VQ decoder
  444.     Synopsis: vq_msd(cb,u,u_est,a,indices,levels,stages,p,conversion)
  445.         Input:
  446.             cb- one dimensional linear codebook array (codebook is structured 
  447.                 as [stages][levels for each stage][p])
  448.             indices- the codebook indices (for each stage) indices[0..stages-1]
  449.             levels- the number of levels (for each stage) levels[0..stages-1]
  450.             u_est- dimension p, the estimated parameters or mean (if NULL, assume
  451.                estimate is the all zero vector) (u_est[0..p-1])
  452.             stages- the number of stages of msvq
  453.             p- the predictor order
  454.             conversion- the conversion constant (see lpc.h, lpc_conv.c)
  455.     diff_Q- the difference between Q value of codebook and u_est
  456.         Output:
  457.             u- dimension p, the decoded parameters (if NULL, use alternate
  458.                temporary storage) (u[0..p-1])
  459.             a- predictor parameters (a[0..p]), if NULL, don't compute
  460.         Returns:
  461.             pointer to reconstruction vector (u)
  462.         Parameters:
  464. */
  466. Shortword *vq_msd2(Shortword *cb, Shortword *u, Shortword *u_est, 
  467.    Shortword *a, Shortword *indices, Shortword *levels, 
  468.    Shortword stages, Shortword p, Shortword conversion,
  469.    Shortword diff_Q)
  470. {
  471.     Shortword *u_hat,*cb_currentstage,*cb_table;
  472.     Shortword i,j;
  473.     Longword *L_u_hat,L_temp;
  475. Shortword temp;
  476. Longword L_temp1;
  478.     /* allocate memory (if required) */
  480.     MEM_ALLOC(MALLOC,L_u_hat,p,Longword);
  482.     if (u==(Shortword*)NULL)
  483.     {
  484.         MEM_ALLOC(MALLOC,u_hat,p,Shortword);
  485.     }
  486.     else
  487.         u_hat = u;
  489.     /* add estimate on (if non-null), or clear vector */
  490.     if (u_est)
  491.     {
  492.         (void)v_equ(u_hat,u_est,p);
  493.     }
  494.     else
  495.     {
  496.         (void)v_zap(u_hat,p);
  497.     }
  499.     /* put u_hat to a long buffer */
  500.     for (i = 0; i < p; i++){
  501.       /* L_u_hat[i] = L_shl(L_deposit_l(u_hat[i]),diff_Q); */
  502.      L_temp1 = (Longword)(u_hat[i]);
  503.          L_u_hat[i] = _sshvl(L_temp1,diff_Q);
  505.       }
  507.     /* add the contribution of each stage */
  508.     cb_currentstage = cb;
  509.     for(i=0; i < stages; i++)
  510.     {
  511.       /* (void)v_add(u_hat,&cb_currentstage[indices[i]*p],p); */
  512.       cb_table = &cb_currentstage[indices[i]*p];   
  513.       for (j = 0; j < p; j++) {
  514. /*  L_temp = L_deposit_l(cb_table[j]);            */
  515. /*         L_u_hat[j] = L_add(L_u_hat[j],L_temp); */
  516.         L_temp = (Longword) (cb_table[j]);
  517. L_u_hat[j] = _sadd(L_u_hat[j],L_temp);
  520.       }
  521.       cb_currentstage += levels[i]*p;
  522.     }
  524.     /* convert long buffer back to u_hat */
  525.     for (i = 0; i < p; i++){
  526.      /*  u_hat[i] = extract_l(L_shr(L_u_hat[i],diff_Q)); */
  527.          L_temp1 = _sshvr(L_u_hat[i],diff_Q);   
  528.  u_hat[i] = (Shortword) (0x0000ffffL & L_temp1);
  529.     }
  530.     MEM_FREE(FREE,L_u_hat);
  532.     return(u);
  533. }
  536. /* VQ_ENC -
  537.    encode vector with full VQ using unweighted Euclidean distance
  538.     Synopsis: vq_enc(cb, u, levels, p, u_hat, indices)
  539.         Input:
  540.             cb- one dimensional linear codebook array
  541.             u- dimension p, the parameters to be encoded (u[0..p-1])
  542.             levels- the number of levels
  543.             p- the predictor order
  544.         Output:
  545.             u_hat-   the reconstruction vector (if non null)
  546.             a_indices- the codebook indices (for each stage) a_indices[0..stages-1]
  547.         Parameters:
  548. */
  549. /* Q values:
  550.    cb - Q13
  551.    u - Q13
  552.    u_hat - Q13 */
  554. Longword vq_enc(Shortword *cb,Shortword *u,Shortword levels,Shortword p, 
  555. Shortword *u_hat,Shortword *indices)
  556. {
  557.     Shortword i,j,index;
  558.     Longword d,dmin;
  559.     Shortword *p_cb;
  560.     Shortword temp;
  561.     
  562.     /* Search codebook for minimum distance */
  563.     index = 0;  //  data_move();mark del
  564.     dmin = LW_MAX;   // L_data_move();mark del
  565.     p_cb = cb;
  566.     for (i = 0; i < levels; i++) {
  567.         d = 0;  //  data_move();mark del
  568.         for (j = 0; j < p; j++) {
  569.   temp = sub(u[j],*p_cb);
  570.           /* d = L_mac(d,temp,temp); */
  571.    d = _sadd(d,_smpy(temp,temp));
  572.           p_cb++;  
  573.         }
  574. // compare_nonzero();mark del 
  575.         if (d < dmin) {
  576.             dmin = d;  //  data_move();mark del
  577.             index = i;   // data_move();mark del
  578.         }
  579.     }
  581.     /* Update index and quantized value, and return minimum distance */
  582.     *indices = index;
  583.     v_equ(u_hat,&cb[p*index],p);
  585.     return(dmin);
  586. } /* vq_enc */
  589. /* VQ_FSW - 
  590.    compute the weights for Euclidean distance of Fourier harmonics  */
  591. /* Q values:
  592.    w_fs - Q14
  593.    pitch - Q9 */
  595. void vq_fsw(Shortword *w_fs, Shortword num_harm, Shortword pitch)
  596. {
  598.     Shortword j;
  599.     Shortword tempw0;
  600.     Shortword temp,denom;
  601.     Longword L_temp;
  603. Longword L_temp1;
  604. Shortword temp1;
  606.     /* Calculate fundamental frequency */
  607.     /* w0 = TWOPI/pitch */
  608.     /* tempw0 = w0/(0.25*PI) = 8/pitch */
  609.     tempw0 = divide_s((Shortword)EIGHT_Q11,pitch);   /* tempw0 in Q17 */
  610.     for(j=0; j < num_harm; j++) {
  612.       /* Bark-scale weighting */
  613.       /* w_fs[j] = 117.0 / (25.0 + 75.0*
  614.            pow(1.0 + 1.4*SQR(w0*(j+1)/(0.25*PI)),0.69)) */
  616.       /* temp = shl(add(j,1),11);     Q11 */ 
  617.   L_temp1 = _sadd2((Longword)j,(Longword)1);
  618.   temp = (Shortword) (0x0000ffffL & L_temp1);
  619.   temp = shl_a(temp,11);
  621.       /* temp = extract_h(L_shl(L_mult(tempw0,temp),1));     Q14 */ 
  622. /*       temp = mult(temp,temp);     Q13 */ 
  623.       L_temp1 = _sshl(_smpy(tempw0,temp),1);
  624.   temp = (Shortword) (0x0000ffffL & (L_temp1 >> 16));
  625.   L_temp1 = _smpy(temp,temp);
  626.   temp =  (Shortword) (0x0000ffffL & (L_temp1 >> 16));
  628.                         
  629.       /* L_temp in Q28 */
  630.    /*    L_temp = L_add((Longword)ONE_Q28,L_mult((Shortword)X14_Q14,temp));       */
  631. /*       temp = L_pow_fxp(L_temp,(Shortword)X069_Q15,28,13);      Q13         */
  632. /*       denom = add((Shortword)X25_Q6,mult((Shortword)X75_Q8,temp));     Q6  */
  633.        L_temp = _sadd((Longword)ONE_Q28,_smpy((Shortword)X14_Q14,temp));
  634.        temp = L_pow_fxp(L_temp,(Shortword)X069_Q15,28,13);      
  635.    L_temp1 = _smpy((Shortword)X75_Q8,temp);
  636.        temp1 = (Shortword) (0x0000ffffL & (L_temp1 >> 16));
  637.    L_temp1 = _sadd2((Longword)X25_Q6,(Longword)temp1);
  638.    denom = (Shortword) (0x0000ffffL &  L_temp1);
  642.       w_fs[j] = divide_s((Shortword)X117_Q5,denom);   /* Q14 */  // data_move();mark del
  643.     }
  644. }