qua_lsp.c
上传用户:zhouyunkk
上传日期:2013-01-10
资源大小:59k
文件大小:12k
源码类别:

语音压缩

开发平台:

C/C++

  1. /*
  2.    ITU-T G.729 Annex C - Reference C code for floating point
  3.                          implementation of G.729
  4.                          Version 1.01 of 15.September.98
  5. */
  6. /*
  7. ----------------------------------------------------------------------
  8.                     COPYRIGHT NOTICE
  9. ----------------------------------------------------------------------
  10.    ITU-T G.729 Annex C ANSI C source code
  11.    Copyright (C) 1998, AT&T, France Telecom, NTT, University of
  12.    Sherbrooke.  All rights reserved.
  13. ----------------------------------------------------------------------
  14. */
  15. /*
  16.  File : QUA_LSP.C
  17.  Used for the floating point version of both
  18.  G.729 main body and G.729A
  19. */
  20. /*----------------------------------------------------------*
  21.  *  qua_lsp.c                                               *
  22.  *  ~~~~~~~~                                                *
  23.  * Functions related to the quantization of LSP's           *
  24.  *----------------------------------------------------------*/
  25. #include <math.h>
  26. #include "typedef.h"
  27. #include "version.h"
  28. #ifdef VER_G729A
  29.  #include "ld8a.h"
  30.  #include "tab_ld8a.h"
  31. #else
  32.  #include "ld8k.h"
  33.  #include "tab_ld8k.h"
  34. #endif
  35. /* Prototype definitions of static functions */
  36. static void get_wegt( FLOAT     flsp[], FLOAT   wegt[] );
  37. static void relspwed( FLOAT *lsp, FLOAT wegt[M], FLOAT *lspq,
  38.                      FLOAT lspcb1[][M], FLOAT lspcb2[][M],
  39.                      FLOAT fg[MODE][MA_NP][M],
  40.                      FLOAT      freq_prev[MA_NP][M], FLOAT fg_sum[MODE][M],
  41.                      FLOAT      fg_sum_inv[MODE][M], int cod[] );
  42. static void lsp_pre_select( FLOAT rbuf[], FLOAT lspcb1[][M], int *cand);
  43. static void lsp_select_1( FLOAT rbuf[], FLOAT   lspcb1[], FLOAT wegt[],
  44.                          FLOAT  lspcb2[][M], int        *index );
  45. static void lsp_select_2( FLOAT rbuf[], FLOAT   lspcb1[], FLOAT wegt[],
  46.                          FLOAT  lspcb2[][M], int *index );
  47. static void lsp_last_select( FLOAT      tdist[MODE], int        *mode_index );
  48. static void lsp_get_tdist( FLOAT        wegt[], FLOAT   buf[],
  49.                           FLOAT *tdist, FLOAT   rbuf[], FLOAT   fg_sum[] );
  50. static void lsp_qua_cs( FLOAT *freq_in, FLOAT *freqout, int *cod);
  51. /* static memory */
  52. static FLOAT freq_prev[MA_NP][M];    /* previous LSP vector       */
  53. static FLOAT freq_prev_reset[M] = {  /* previous LSP vector(init) */
  54.  (F)0.285599,  (F)0.571199,  (F)0.856798,  (F)1.142397,  (F)1.427997,
  55.  (F)1.713596,  (F)1.999195,  (F)2.284795,  (F)2.570394,  (F)2.855993
  56. };     /* PI*(float)(j+1)/(float)(M+1) */
  57. void qua_lsp(
  58.   FLOAT lsp[],       /* (i) : Unquantized LSP            */
  59.   FLOAT lsp_q[],     /* (o) : Quantized LSP              */
  60.   int ana[]          /* (o) : indexes                    */
  61. )
  62. {
  63.   int i;
  64.   FLOAT lsf[M], lsf_q[M];  /* domain 0.0<= lsf <PI */
  65.   /* Convert LSPs to LSFs */
  66.   for (i=0; i<M; i++ )
  67.      lsf[i] = (FLOAT)acos(lsp[i]);
  68.   lsp_qua_cs(lsf, lsf_q, ana );
  69.   /* Convert LSFs to LSPs */
  70.   for (i=0; i<M; i++ )
  71.      lsp_q[i] = (FLOAT)cos(lsf_q[i]);
  72.   return;
  73. }
  74. /*----------------------------------------------------------------------------
  75.  * lsp_encw_reset - set the previous LSP vector
  76.  *----------------------------------------------------------------------------
  77.  */
  78. void lsp_encw_reset(
  79.  void
  80. )
  81. {
  82.    int  i;
  83.    for(i=0; i<MA_NP; i++)
  84.      copy (&freq_prev_reset[0], &freq_prev[i][0], M );
  85.    return;
  86. }
  87. /*----------------------------------------------------------------------------
  88.  * lsp_qua_cs - lsp quantizer
  89.  *----------------------------------------------------------------------------
  90.  */
  91. static void lsp_qua_cs(
  92.  FLOAT  *flsp_in,       /*  input : Original LSP parameters      */
  93.  FLOAT  *lspq_out,       /*  output: Quantized LSP parameters     */
  94.  int  *code             /*  output: codes of the selected LSP    */
  95. )
  96. {
  97.    FLOAT        wegt[M];   /* weight coef. */
  98.    get_wegt( flsp_in, wegt );
  99.    relspwed( flsp_in, wegt, lspq_out, lspcb1, lspcb2, fg,
  100.             freq_prev, fg_sum, fg_sum_inv, code);
  101.    return;
  102. }
  103. /*----------------------------------------------------------------------------
  104.  * relspwed -
  105.  *----------------------------------------------------------------------------
  106.  */
  107. static void relspwed(
  108.  FLOAT  lsp[],                  /*input: unquantized LSP parameters  */
  109.  FLOAT  wegt[],                 /*input: weight coef.                */
  110.  FLOAT  lspq[],                 /*output:quantized LSP parameters    */
  111.  FLOAT  lspcb1[][M],            /*input: first stage LSP codebook    */
  112.  FLOAT  lspcb2[][M],            /*input: Second stage LSP codebook   */
  113.  FLOAT  fg[MODE][MA_NP][M],     /*input: MA prediction coef.         */
  114.  FLOAT  freq_prev[MA_NP][M],    /*input: previous LSP vector         */
  115.  FLOAT  fg_sum[MODE][M],        /*input: present MA prediction coef. */
  116.  FLOAT  fg_sum_inv[MODE][M],    /*input: inverse coef.               */
  117.  int    code_ana[]              /*output:codes of the selected LSP   */
  118. )
  119. {
  120.    int  mode, j;
  121.    int  index, mode_index;
  122.    int  cand[MODE], cand_cur;
  123.    int  tindex1[MODE], tindex2[MODE];
  124.    FLOAT        tdist[MODE];
  125.    FLOAT        rbuf[M];
  126.    FLOAT        buf[M];
  127.    for(mode = 0; mode<MODE; mode++) {
  128.       lsp_prev_extract(lsp, rbuf, fg[mode], freq_prev, fg_sum_inv[mode]);
  129.       /*----- search the first stage lsp codebook -----*/
  130.       lsp_pre_select(rbuf, lspcb1, &cand_cur);
  131.       cand[mode]=cand_cur;
  132.       /*----- search the second stage lsp codebook (lower 0-4) ----- */
  133.       lsp_select_1(rbuf, lspcb1[cand_cur], wegt, lspcb2, &index);
  134.       tindex1[mode] = index;
  135.       for(j=0; j<NC; j++)
  136.         buf[j]=lspcb1[cand_cur][j]+lspcb2[index][j];
  137.       lsp_expand_1(buf, GAP1);  /* check */
  138.       /*----- search the second stage lsp codebook (Higher 5-9) ----- */
  139.       lsp_select_2(rbuf, lspcb1[cand_cur], wegt, lspcb2,
  140.                    &index);
  141.       tindex2[mode] = index;
  142.       for(j=NC; j<M; j++)
  143.         buf[j]=lspcb1[cand_cur][j]+lspcb2[index][j];
  144.       lsp_expand_2(buf, GAP1);  /* check */
  145.       /* check */
  146.       lsp_expand_1_2(buf, GAP2);
  147.       lsp_get_tdist(wegt, buf, &tdist[mode], rbuf,
  148.                     fg_sum[mode]);  /* calculate the distortion */
  149.    } /* mode */
  150.    lsp_last_select(tdist, &mode_index); /* select the codes */
  151.    /* pack codes for lsp parameters */
  152.    code_ana[0] = (mode_index<<NC0_B) | cand[mode_index];
  153.    code_ana[1] = (tindex1[mode_index]<<NC1_B) | tindex2[mode_index];
  154.    /* reconstruct quantized LSP parameter and check the stabilty */
  155.    lsp_get_quant(lspcb1, lspcb2, cand[mode_index],
  156.                  tindex1[mode_index], tindex2[mode_index],
  157.                  fg[mode_index],
  158.                  freq_prev,
  159.                  lspq, fg_sum[mode_index]);
  160.     return;
  161. }
  162. /*----------------------------------------------------------------------------
  163.  * lsp_pre_select - select the code of first stage lsp codebook
  164.  *----------------------------------------------------------------------------
  165.  */
  166. static void lsp_pre_select(
  167.  FLOAT  rbuf[],         /*input : target vetor             */
  168.  FLOAT  lspcb1[][M],    /*input : first stage lsp codebook */
  169.  int    *cand           /*output: selected code            */
  170. )
  171. {
  172.    int  i, j;
  173.    FLOAT dmin, dist, temp;
  174.    /* calculate the distortion */
  175.    *cand = 0;
  176.    dmin= FLT_MAX_G729;
  177.    for(i=0; i<NC0; i++) {
  178.       dist =(F)0.;
  179.       for(j=0; j<M; j++){
  180.         temp = rbuf[j]-lspcb1[i][j];
  181.         dist += temp * temp;
  182.       }
  183.       if(dist<dmin)
  184.       {
  185.         dmin=dist;
  186.         *cand=i;
  187.       }
  188.     }
  189.     return;
  190. }
  191. /*----------------------------------------------------------------------------
  192.  * lsp_pre_select_1 - select the code of second stage lsp codebook (lower 0-4)
  193.  *----------------------------------------------------------------------------
  194.  */
  195. static void lsp_select_1(
  196.  FLOAT  rbuf[],         /*input : target vector            */
  197.  FLOAT  lspcb1[],       /*input : first stage lsp codebook */
  198.  FLOAT  wegt[],         /*input : weight coef.             */
  199.  FLOAT  lspcb2[][M],    /*input : second stage lsp codebook*/
  200.  int    *index          /*output: selected codebook index     */
  201. )
  202. {
  203.    int  j, k1;
  204.    FLOAT        buf[M];
  205.    FLOAT        dist, dmin, tmp;
  206.    for(j=0; j<NC; j++)
  207.         buf[j]=rbuf[j]-lspcb1[j];
  208.    *index = 0;
  209.    dmin=FLT_MAX_G729;
  210.    for(k1 = 0; k1<NC1; k1++) {
  211.       /* calculate the distortion */
  212.       dist = (F)0.;
  213.       for(j=0; j<NC; j++) {
  214.          tmp = buf[j]-lspcb2[k1][j];
  215.          dist += wegt[j] * tmp * tmp;
  216.       }
  217.       if(dist<dmin) {
  218.          dmin = dist;
  219.          *index = k1;
  220.       }
  221.    }
  222.     return;
  223. }
  224. /*----------------------------------------------------------------------------
  225.  * lsp_pre_select_2 - select the code of second stage lsp codebook (higher 5-9)
  226.  *----------------------------------------------------------------------------
  227.  */
  228. static void lsp_select_2(
  229.  FLOAT  rbuf[],         /*input : target vector            */
  230.  FLOAT  lspcb1[],       /*input : first stage lsp codebook */
  231.  FLOAT  wegt[],         /*input : weighting coef.             */
  232.  FLOAT  lspcb2[][M],    /*input : second stage lsp codebook*/
  233.  int    *index          /*output: selected codebook index    */
  234. )
  235. {
  236.    int  j, k1;
  237.    FLOAT        buf[M];
  238.    FLOAT        dist, dmin, tmp;
  239.    for(j=NC; j<M; j++)
  240.         buf[j]=rbuf[j]-lspcb1[j];
  241.    *index = 0;
  242.    dmin= FLT_MAX_G729;
  243.    for(k1 = 0; k1<NC1; k1++) {
  244.       dist = (F)0.0;
  245.       for(j=NC; j<M; j++) {
  246.         tmp = buf[j] - lspcb2[k1][j];
  247.         dist += wegt[j] * tmp * tmp;
  248.       }
  249.       if(dist<dmin) {
  250.          dmin = dist;
  251.          *index = k1;
  252.       }
  253.    }
  254.    return;
  255. }
  256. /*----------------------------------------------------------------------------
  257.  * lsp_get_tdist - calculate the distortion
  258.  *----------------------------------------------------------------------------
  259.  */
  260. static void lsp_get_tdist(
  261.  FLOAT  wegt[],         /*input : weight coef.          */
  262.  FLOAT  buf[],          /*input : candidate LSP vector  */
  263.  FLOAT  *tdist,         /*output: distortion            */
  264.  FLOAT  rbuf[],         /*input : target vector         */
  265.  FLOAT  fg_sum[]        /*input : present MA prediction coef.  */
  266. )
  267. {
  268.    int  j;
  269.    FLOAT        tmp;
  270.    *tdist = (F)0.0;
  271.    for(j=0; j<M; j++) {
  272.       tmp = (buf[j] - rbuf[j]) * fg_sum[j];
  273.       *tdist += wegt[j] * tmp * tmp;
  274.    }
  275.    return;
  276. }
  277. /*----------------------------------------------------------------------------
  278.  * lsp_last_select - select the mode
  279.  *----------------------------------------------------------------------------
  280.  */
  281. static void lsp_last_select(
  282.  FLOAT  tdist[],        /*input : distortion         */
  283.  int    *mode_index     /*output: the selected mode  */
  284. )
  285. {
  286.    *mode_index = 0;
  287.    if( tdist[1] < tdist[0] ) *mode_index = 1;
  288.    return;
  289. }
  290. /*----------------------------------------------------------------------------
  291.  * get_wegt - compute lsp weights
  292.  *----------------------------------------------------------------------------
  293.  */
  294. static void get_wegt(
  295.  FLOAT  flsp[],         /* input : M LSP parameters */
  296.  FLOAT  wegt[]          /* output: M weighting coefficients */
  297. )
  298. {
  299.    int  i;
  300.    FLOAT        tmp;
  301.    tmp = flsp[1] - PI04 - (F)1.0;
  302.    if (tmp > (F)0.0)       wegt[0] = (F)1.0;
  303.    else         wegt[0] = tmp * tmp * (F)10. + (F)1.0;
  304.    for ( i=1; i<M-1; i++ ) {
  305.       tmp = flsp[i+1] - flsp[i-1] - (F)1.0;
  306.       if (tmp > (F)0.0)    wegt[i] = (F)1.0;
  307.       else              wegt[i] = tmp * tmp * (F)10. + (F)1.0;
  308.    }
  309.    tmp = PI92 - flsp[M-2] - (F)1.0;
  310.    if (tmp > (F)0.0)       wegt[M-1] = (F)1.0;
  311.    else         wegt[M-1] = tmp * tmp * (F)10. + (F)1.0;
  312.    wegt[4] *= CONST12;
  313.    wegt[5] *= CONST12;
  314.    return;
  315. }