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

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

语音压缩

开发平台：

C/C++

QUA_GAIN.C：源码内容
  1. /*
  2.    ITU-T G.729A Speech Coder    ANSI-C Source Code
  3.    Version 1.1    Last modified: September 1996
  5.    Copyright (c) 1996,
  6.    AT&T, France Telecom, NTT, Universite de Sherbrooke
  7.    All rights reserved.
  8. */
  10. #include "typedef.h"
  11. #include "basic_op.h"
  12. #include "oper_32b.h"
  14. #include "ld8a.h"
  15. #include "tab_ld8a.h"
  17. static void Gbk_presel(
  18.    Word16 best_gain[],     /* (i) [0] Q9 : unquantized pitch gain     */
  19.                            /* (i) [1] Q2 : unquantized code gain      */
  20.    Word16 *cand1,          /* (o)    : index of best 1st stage vector */
  21.    Word16 *cand2,          /* (o)    : index of best 2nd stage vector */
  22.    Word16 gcode0           /* (i) Q4 : presearch for gain codebook    */
  23. );
  26. /*---------------------------------------------------------------------------*
  27.  * Function  Qua_gain                                                        *
  28.  * ~~~~~~~~~~~~~~~~~~                                                        *
  29.  * Inputs:                                                                   *
  30.  *   code[]     :Innovative codebook.                                        *
  31.  *   g_coeff[]  :Correlations compute for pitch.                             *
  32.  *   L_subfr    :Subframe length.                                            *
  33.  *                                                                           *
  34.  * Outputs:                                                                  *
  35.  *   gain_pit   :Quantized pitch gain.                                       *
  36.  *   gain_cod   :Quantized code gain.                                        *
  37.  *                                                                           *
  38.  * Return:                                                                   *
  39.  *   Index of quantization.                                                  *
  40.  *                                                                           *
  41.  *--------------------------------------------------------------------------*/
  42. Word16 Qua_gain(
  43.    Word16 code[],       /* (i) Q13 :Innovative vector.             */
  44.    Word16 g_coeff[],    /* (i)     :Correlations <xn y1> -2<y1 y1> */
  45.                         /*            <y2,y2>, -2<xn,y2>, 2<y1,y2> */
  46.    Word16 exp_coeff[],  /* (i)     :Q-Format g_coeff[]             */
  47.    Word16 L_subfr,      /* (i)     :Subframe length.               */
  48.    Word16 *gain_pit,    /* (o) Q14 :Pitch gain.                    */
  49.    Word16 *gain_cod,    /* (o) Q1  :Code gain.                     */
  50.    Word16 tameflag      /* (i)     : set to 1 if taming is needed  */
  51. )
  52. {
  53.    Word16  i, j, index1, index2;
  54.    Word16  cand1, cand2;
  55.    Word16  exp, gcode0, exp_gcode0, gcode0_org, e_min ;
  56.    Word16  nume, denom, inv_denom;
  57.    Word16  exp1,exp2,exp_nume,exp_denom,exp_inv_denom,sft,tmp;
  58.    Word16  g_pitch, g2_pitch, g_code, g2_code, g_pit_cod;
  59.    Word16  coeff[5], coeff_lsf[5];
  60.    Word16  exp_min[5];
  61.    Word32  L_gbk12;
  62.    Word32  L_tmp, L_dist_min, L_temp, L_tmp1, L_tmp2, L_acc, L_accb;
  63.    Word16  best_gain[2];
  65.         /* Gain predictor, Past quantized energies = -14.0 in Q10 */
  67.  static Word16 past_qua_en[4] = { -14336, -14336, -14336, -14336 };
  69.   /*---------------------------------------------------*
  70.    *-  energy due to innovation                       -*
  71.    *-  predicted energy                               -*
  72.    *-  predicted codebook gain => gcode0[exp_gcode0]  -*
  73.    *---------------------------------------------------*/
  75.    Gain_predict( past_qua_en, code, L_subfr, &gcode0, &exp_gcode0 );
  77.   /*-----------------------------------------------------------------*
  78.    *  pre-selection                                                  *
  79.    *-----------------------------------------------------------------*/
  80.   /*-----------------------------------------------------------------*
  81.    *  calculate best gain                                            *
  82.    *                                                                 *
  83.    *  tmp = -1./(4.*coeff[0]*coeff[2]-coeff[4]*coeff[4]) ;           *
  84.    *  best_gain[0] = (2.*coeff[2]*coeff[1]-coeff[3]*coeff[4])*tmp ;  *
  85.    *  best_gain[1] = (2.*coeff[0]*coeff[3]-coeff[1]*coeff[4])*tmp ;  *
  86.    *  gbk_presel(best_gain,&cand1,&cand2,gcode0) ;                   *
  87.    *                                                                 *
  88.    *-----------------------------------------------------------------*/
  90.   /*-----------------------------------------------------------------*
  91.    *  tmp = -1./(4.*coeff[0]*coeff[2]-coeff[4]*coeff[4]) ;           *
  92.    *-----------------------------------------------------------------*/
  93.    L_tmp1 = L_mult( g_coeff[0], g_coeff[2] );
  94.    exp1   = add( add( exp_coeff[0], exp_coeff[2] ), 1-2 );
  95.    L_tmp2 = L_mult( g_coeff[4], g_coeff[4] );
  96.    exp2   = add( add( exp_coeff[4], exp_coeff[4] ), 1 );
  98.    if( sub(exp1, exp2)>0 ){
  99.       L_tmp = L_sub( L_shr( L_tmp1, sub(exp1,exp2) ), L_tmp2 );
  100.       exp = exp2;
  101.    }
  102.    else{
  103.       L_tmp = L_sub( L_tmp1, L_shr( L_tmp2, sub(exp2,exp1) ) );
  104.       exp = exp1;
  105.    }
  106.    sft = norm_l( L_tmp );
  107.    denom = extract_h( L_shl(L_tmp, sft) );
  108.    exp_denom = sub( add( exp, sft ), 16 );
  110.    inv_denom = div_s(16384,denom);
  111.    inv_denom = negate( inv_denom );
  112.    exp_inv_denom = sub( 14+15, exp_denom );
  114.   /*-----------------------------------------------------------------*
  115.    *  best_gain[0] = (2.*coeff[2]*coeff[1]-coeff[3]*coeff[4])*tmp ;  *
  116.    *-----------------------------------------------------------------*/
  117.    L_tmp1 = L_mult( g_coeff[2], g_coeff[1] );
  118.    exp1   = add( exp_coeff[2], exp_coeff[1] );
  119.    L_tmp2 = L_mult( g_coeff[3], g_coeff[4] );
  120.    exp2   = add( add( exp_coeff[3], exp_coeff[4] ), 1 );
  122.    if( sub(exp1, exp2)>0 ){
  123.       L_tmp = L_sub( L_shr( L_tmp1, add(sub(exp1,exp2),1 )), L_shr( L_tmp2,1 ) );
  124.       exp = sub(exp2,1);
  125.    }
  126.    else{
  127.       L_tmp = L_sub( L_shr( L_tmp1,1 ), L_shr( L_tmp2, add(sub(exp2,exp1),1 )) );
  128.       exp = sub(exp1,1);
  129.    }
  130.    sft = norm_l( L_tmp );
  131.    nume = extract_h( L_shl(L_tmp, sft) );
  132.    exp_nume = sub( add( exp, sft ), 16 );
  134.    sft = sub( add( exp_nume, exp_inv_denom ), (9+16-1) );
  135.    L_acc = L_shr( L_mult( nume,inv_denom ), sft );
  136.    best_gain[0] = extract_h( L_acc );             /*-- best_gain[0]:Q9 --*/
  138.    if (tameflag == 1){
  139.      if(sub(best_gain[0], GPCLIP2) > 0) best_gain[0] = GPCLIP2;
  140.    }
  142.   /*-----------------------------------------------------------------*
  143.    *  best_gain[1] = (2.*coeff[0]*coeff[3]-coeff[1]*coeff[4])*tmp ;  *
  144.    *-----------------------------------------------------------------*/
  145.    L_tmp1 = L_mult( g_coeff[0], g_coeff[3] );
  146.    exp1   = add( exp_coeff[0], exp_coeff[3] ) ;
  147.    L_tmp2 = L_mult( g_coeff[1], g_coeff[4] );
  148.    exp2   = add( add( exp_coeff[1], exp_coeff[4] ), 1 );
  150.    if( sub(exp1, exp2)>0 ){
  151.       L_tmp = L_sub( L_shr( L_tmp1, add(sub(exp1,exp2),1) ), L_shr( L_tmp2,1 ) );
  152.       exp = sub(exp2,1);
  153.    }
  154.    else{
  155.       L_tmp = L_sub( L_shr( L_tmp1,1 ), L_shr( L_tmp2, add(sub(exp2,exp1),1) ) );
  156.       exp = sub(exp1,1);
  157.    }
  158.    sft = norm_l( L_tmp );
  159.    nume = extract_h( L_shl(L_tmp, sft) );
  160.    exp_nume = sub( add( exp, sft ), 16 );
  162.    sft = sub( add( exp_nume, exp_inv_denom ), (2+16-1) );
  163.    L_acc = L_shr( L_mult( nume,inv_denom ), sft );
  164.    best_gain[1] = extract_h( L_acc );             /*-- best_gain[1]:Q2 --*/
  166.    /*--- Change Q-format of gcode0 ( Q[exp_gcode0] -> Q4 ) ---*/
  167.    if( sub(exp_gcode0,4) >= 0 ){
  168.       gcode0_org = shr( gcode0, sub(exp_gcode0,4) );
  169.    }
  170.    else{
  171.       L_acc = L_deposit_l( gcode0 );
  172.       L_acc = L_shl( L_acc, sub( (4+16), exp_gcode0 ) );
  173.       gcode0_org = extract_h( L_acc );              /*-- gcode0_org:Q4 --*/
  174.    }
  176.   /*----------------------------------------------*
  177.    *   - presearch for gain codebook -            *
  178.    *----------------------------------------------*/
  180.    Gbk_presel(best_gain, &cand1, &cand2, gcode0_org );
  182. /*---------------------------------------------------------------------------*
  183.  *                                                                           *
  184.  * Find the best quantizer.                                                  *
  185.  *                                                                           *
  186.  *  dist_min = MAX_32;                                                       *
  187.  *  for ( i=0 ; i<NCAN1 ; i++ ){                                             *
  188.  *    for ( j=0 ; j<NCAN2 ; j++ ){                                           *
  189.  *      g_pitch = gbk1[cand1+i][0] + gbk2[cand2+j][0];                       *
  190.  *      g_code = gcode0 * (gbk1[cand1+i][1] + gbk2[cand2+j][1]);             *
  191.  *      dist = g_pitch*g_pitch * coeff[0]                                    *
  192.  *           + g_pitch         * coeff[1]                                    *
  193.  *           + g_code*g_code   * coeff[2]                                    *
  194.  *           + g_code          * coeff[3]                                    *
  195.  *           + g_pitch*g_code  * coeff[4] ;                                  *
  196.  *                                                                           *
  197.  *      if (dist < dist_min){                                                *
  198.  *        dist_min = dist;                                                   *
  199.  *        indice1 = cand1 + i ;                                              *
  200.  *        indice2 = cand2 + j ;                                              *
  201.  *      }                                                                    *
  202.  *    }                                                                      *
  203.  *  }                                                                        *
  204.  *                                                                           *
  205.  * g_pitch         = Q13                                                     *
  206.  * g_pitch*g_pitch = Q11:(13+13+1-16)                                        *
  207.  * g_code          = Q[exp_gcode0-3]:(exp_gcode0+(13-1)+1-16)                *
  208.  * g_code*g_code   = Q[2*exp_gcode0-21]:(exp_gcode0-3+exp_gcode0-3+1-16)     *
  209.  * g_pitch*g_code  = Q[exp_gcode0-5]:(13+exp_gcode0-3+1-16)                  *
  210.  *                                                                           *
  211.  * term 0: g_pitch*g_pitch*coeff[0] ;exp_min0 = 13             +exp_coeff[0] *
  212.  * term 1: g_pitch        *coeff[1] ;exp_min1 = 14             +exp_coeff[1] *
  213.  * term 2: g_code*g_code  *coeff[2] ;exp_min2 = 2*exp_gcode0-21+exp_coeff[2] *
  214.  * term 3: g_code         *coeff[3] ;exp_min3 = exp_gcode0  - 3+exp_coeff[3] *
  215.  * term 4: g_pitch*g_code *coeff[4] ;exp_min4 = exp_gcode0  - 4+exp_coeff[4] *
  216.  *                                                                           *
  217.  *---------------------------------------------------------------------------*/
  219.    exp_min[0] = add( exp_coeff[0], 13 );
  220.    exp_min[1] = add( exp_coeff[1], 14 );
  221.    exp_min[2] = add( exp_coeff[2], sub( shl( exp_gcode0, 1 ), 21 ) );
  222.    exp_min[3] = add( exp_coeff[3], sub( exp_gcode0, 3 ) );
  223.    exp_min[4] = add( exp_coeff[4], sub( exp_gcode0, 4 ) );
  225.    e_min = exp_min[0];
  226.    for(i=1; i<5; i++){
  227.       if( sub(exp_min[i], e_min) < 0 ){
  228.          e_min = exp_min[i];
  229.       }
  230.    }
  232.    /* align coeff[] and save in special 32 bit double precision */
  234.    for(i=0; i<5; i++){
  235.      j = sub( exp_min[i], e_min );
  236.      L_tmp = L_deposit_h( g_coeff[i] );
  237.      L_tmp = L_shr( L_tmp, j );          /* L_tmp:Q[exp_g_coeff[i]+16-j] */
  238.      L_Extract( L_tmp, &coeff[i], &coeff_lsf[i] );          /* DPF */
  239.    }
  241.    /* Codebook search */
  243.    L_dist_min = MAX_32;
  245.    /* initialization used only to suppress Microsoft Visual C++  warnings */
  246.    index1 = cand1;
  247.    index2 = cand2;
  249. if(tameflag == 1){
  250.    for(i=0; i<NCAN1; i++){
  251.       for(j=0; j<NCAN2; j++){
  252.          g_pitch = add( gbk1[cand1+i][0], gbk2[cand2+j][0] );     /* Q14 */
  253.          if(g_pitch < GP0999) {
  254.          L_acc = L_deposit_l( gbk1[cand1+i][1] );
  255.          L_accb = L_deposit_l( gbk2[cand2+j][1] );                /* Q13 */
  256.          L_tmp = L_add( L_acc,L_accb );
  257.          tmp = extract_l( L_shr( L_tmp,1 ) );                     /* Q12 */
  259.          g_code   = mult( gcode0, tmp );         /*  Q[exp_gcode0+12-15] */
  260.          g2_pitch = mult(g_pitch, g_pitch);                       /* Q13 */
  261.          g2_code  = mult(g_code,  g_code);       /* Q[2*exp_gcode0-6-15] */
  262.          g_pit_cod= mult(g_code,  g_pitch);      /* Q[exp_gcode0-3+14-15] */
  264.          L_tmp = Mpy_32_16(coeff[0], coeff_lsf[0], g2_pitch);
  265.          L_tmp = L_add(L_tmp, Mpy_32_16(coeff[1], coeff_lsf[1], g_pitch) );
  266.          L_tmp = L_add(L_tmp, Mpy_32_16(coeff[2], coeff_lsf[2], g2_code) );
  267.          L_tmp = L_add(L_tmp, Mpy_32_16(coeff[3], coeff_lsf[3], g_code) );
  268.          L_tmp = L_add(L_tmp, Mpy_32_16(coeff[4], coeff_lsf[4], g_pit_cod) );
  270.          L_temp = L_sub(L_tmp, L_dist_min);
  272.          if( L_temp < 0L ){
  273.             L_dist_min = L_tmp;
  274.             index1 = add(cand1,i);
  275.             index2 = add(cand2,j);
  276.          }
  277.         }
  278.       }
  279.    }
  281. }
  282. else{
  283.    for(i=0; i<NCAN1; i++){
  284.       for(j=0; j<NCAN2; j++){
  285.          g_pitch = add( gbk1[cand1+i][0], gbk2[cand2+j][0] );     /* Q14 */
  286.          L_acc = L_deposit_l( gbk1[cand1+i][1] );
  287.          L_accb = L_deposit_l( gbk2[cand2+j][1] );                /* Q13 */
  288.          L_tmp = L_add( L_acc,L_accb );
  289.          tmp = extract_l( L_shr( L_tmp,1 ) );                     /* Q12 */
  291.          g_code   = mult( gcode0, tmp );         /*  Q[exp_gcode0+12-15] */
  292.          g2_pitch = mult(g_pitch, g_pitch);                       /* Q13 */
  293.          g2_code  = mult(g_code,  g_code);       /* Q[2*exp_gcode0-6-15] */
  294.          g_pit_cod= mult(g_code,  g_pitch);      /* Q[exp_gcode0-3+14-15] */
  296.          L_tmp = Mpy_32_16(coeff[0], coeff_lsf[0], g2_pitch);
  297.          L_tmp = L_add(L_tmp, Mpy_32_16(coeff[1], coeff_lsf[1], g_pitch) );
  298.          L_tmp = L_add(L_tmp, Mpy_32_16(coeff[2], coeff_lsf[2], g2_code) );
  299.          L_tmp = L_add(L_tmp, Mpy_32_16(coeff[3], coeff_lsf[3], g_code) );
  300.          L_tmp = L_add(L_tmp, Mpy_32_16(coeff[4], coeff_lsf[4], g_pit_cod) );
  302.          L_temp = L_sub(L_tmp, L_dist_min);
  304.          if( L_temp < 0L ){
  305.             L_dist_min = L_tmp;
  306.             index1 = add(cand1,i);
  307.             index2 = add(cand2,j);
  308.          }
  310.       }
  311.    }
  312. }
  313.    /* Read the quantized gain */
  315.   /*-----------------------------------------------------------------*
  316.    * *gain_pit = gbk1[indice1][0] + gbk2[indice2][0];                *
  317.    *-----------------------------------------------------------------*/
  318.    *gain_pit = add( gbk1[index1][0], gbk2[index2][0] );      /* Q14 */
  320.   /*-----------------------------------------------------------------*
  321.    * *gain_code = (gbk1[indice1][1]+gbk2[indice2][1]) * gcode0;      *
  322.    *-----------------------------------------------------------------*/
  323.    L_acc = L_deposit_l( gbk1[index1][1] );
  324.    L_accb = L_deposit_l( gbk2[index2][1] );
  325.    L_gbk12 = L_add( L_acc, L_accb );                          /* Q13 */
  326.    tmp = extract_l( L_shr( L_gbk12,1 ) );                     /* Q12 */
  327.    L_acc = L_mult(tmp, gcode0);                /* Q[exp_gcode0+12+1] */
  329.    L_acc = L_shl(L_acc, add( negate(exp_gcode0),(-12-1+1+16) ));
  330.    *gain_cod = extract_h( L_acc );                             /* Q1 */
  332.   /*----------------------------------------------*
  333.    * update table of past quantized energies      *
  334.    *----------------------------------------------*/
  335.    Gain_update( past_qua_en, L_gbk12 );
  337.    return( add( map1[index1]*(Word16)NCODE2, map2[index2] ) );
  339. }
  340. /*---------------------------------------------------------------------------*
  341.  * Function Gbk_presel                                                       *
  342.  * ~~~~~~~~~~~~~~~~~~~                                                       *
  343.  *   - presearch for gain codebook -                                         *
  344.  *---------------------------------------------------------------------------*/
  345. static void Gbk_presel(
  346.    Word16 best_gain[],     /* (i) [0] Q9 : unquantized pitch gain     */
  347.                            /* (i) [1] Q2 : unquantized code gain      */
  348.    Word16 *cand1,          /* (o)    : index of best 1st stage vector */
  349.    Word16 *cand2,          /* (o)    : index of best 2nd stage vector */
  350.    Word16 gcode0           /* (i) Q4 : presearch for gain codebook    */
  351. )
  352. {
  353.    Word16    acc_h;
  354.    Word16    sft_x,sft_y;
  355.    Word32    L_acc,L_preg,L_cfbg,L_tmp,L_tmp_x,L_tmp_y;
  356.    Word32 L_temp;
  358.  /*--------------------------------------------------------------------------*
  359.    x = (best_gain[1]-(coef[0][0]*best_gain[0]+coef[1][1])*gcode0) * inv_coef;
  360.   *--------------------------------------------------------------------------*/
  361.    L_cfbg = L_mult( coef[0][0], best_gain[0] );        /* L_cfbg:Q20 -> !!y */
  362.    L_acc = L_shr( L_coef[1][1], 15 );                  /* L_acc:Q20     */
  363.    L_acc = L_add( L_cfbg , L_acc );
  364.    acc_h = extract_h( L_acc );                         /* acc_h:Q4      */
  365.    L_preg = L_mult( acc_h, gcode0 );                   /* L_preg:Q9     */
  366.    L_acc = L_shl( L_deposit_l( best_gain[1] ), 7 );    /* L_acc:Q9      */
  367.    L_acc = L_sub( L_acc, L_preg );
  368.    acc_h = extract_h( L_shl( L_acc,2 ) );              /* L_acc_h:Q[-5] */
  369.    L_tmp_x = L_mult( acc_h, INV_COEF );                /* L_tmp_x:Q15   */
  371.  /*--------------------------------------------------------------------------*
  372.    y = (coef[1][0]*(-coef[0][1]+best_gain[0]*coef[0][0])*gcode0
  373.                                       -coef[0][0]*best_gain[1]) * inv_coef;
  374.   *--------------------------------------------------------------------------*/
  375.    L_acc = L_shr( L_coef[0][1], 10 );                  /* L_acc:Q20   */
  376.    L_acc = L_sub( L_cfbg, L_acc );                     /* !!x -> L_cfbg:Q20 */
  377.    acc_h = extract_h( L_acc );                         /* acc_h:Q4    */
  378.    acc_h = mult( acc_h, gcode0 );                      /* acc_h:Q[-7] */
  379.    L_tmp = L_mult( acc_h, coef[1][0] );                /* L_tmp:Q10   */
  381.    L_preg = L_mult( coef[0][0], best_gain[1] );        /* L_preg:Q13  */
  382.    L_acc = L_sub( L_tmp, L_shr(L_preg,3) );            /* L_acc:Q10   */
  384.    acc_h = extract_h( L_shl( L_acc,2 ) );              /* acc_h:Q[-4] */
  385.    L_tmp_y = L_mult( acc_h, INV_COEF );                /* L_tmp_y:Q16 */
  387.    sft_y = (14+4+1)-16;         /* (Q[thr1]+Q[gcode0]+1)-Q[L_tmp_y] */
  388.    sft_x = (15+4+1)-15;         /* (Q[thr2]+Q[gcode0]+1)-Q[L_tmp_x] */
  390.    if(gcode0>0){
  391.       /*-- pre select codebook #1 --*/
  392.       *cand1 = 0 ;
  393.       do{
  394.          L_temp = L_sub( L_tmp_y, L_shr(L_mult(thr1[*cand1],gcode0),sft_y));
  395.          if(L_temp >0L  ){
  396.         (*cand1) =add(*cand1,1);
  397.      }
  398.          else               break ;
  399.       } while(sub((*cand1),(NCODE1-NCAN1))<0) ;
  400.       /*-- pre select codebook #2 --*/
  401.       *cand2 = 0 ;
  402.       do{
  403.         L_temp = L_sub( L_tmp_x , L_shr(L_mult(thr2[*cand2],gcode0),sft_x));
  404.          if( L_temp >0L) {
  405.         (*cand2) =add(*cand2,1);
  406.      }
  407.          else               break ;
  408.       } while(sub((*cand2),(NCODE2-NCAN2))<0) ;
  409.    }
  410.    else{
  411.       /*-- pre select codebook #1 --*/
  412.       *cand1 = 0 ;
  413.       do{
  414.         L_temp = L_sub(L_tmp_y ,L_shr(L_mult(thr1[*cand1],gcode0),sft_y));
  415.          if( L_temp <0L){
  416.         (*cand1) =add(*cand1,1);
  417.      }
  418.          else               break ;
  419.       } while(sub((*cand1),(NCODE1-NCAN1))) ;
  420.       /*-- pre select codebook #2 --*/
  421.       *cand2 = 0 ;
  422.       do{
  423.          L_temp =L_sub(L_tmp_x ,L_shr(L_mult(thr2[*cand2],gcode0),sft_x));
  424.          if( L_temp <0L){
  425.         (*cand2) =add(*cand2,1);
  426.      }
  427.          else               break ;
  428.       } while(sub( (*cand2),(NCODE2-NCAN2))) ;
  429.    }
  431.    return ;
  432. }