www.pudn.com > 200411301125332697.rar > qsidlsf.c

/* 
   ITU-T G.729 Annex B     ANSI-C Source Code 
   Version 1.3    Last modified: August 1997 
 
   Copyright (c) 1996, France Telecom, Rockwell International, 
                       Universite de Sherbrooke. 
   All rights reserved. 
*/ 
 
 
#include  
 
#include "typedef.h" 
#include "basic_op.h" 
#include "ld8k.h" 
#include "tab_ld8k.h" 
#include "sid.h" 
#include "vad.h" 
#include "dtx.h" 
#include "tab_dtx.h" 
 
/* local functions */ 
static void Qnt_e(Word16 *errlsf,    /* (i)  : error lsf vector             */ 
                  Word16 *weight,    /* (i)  : weighting vector             */ 
                  Word16 DIn,        /* (i)  : number of input candidates   */ 
                  Word16 *qlsf,      /* (o)  : quantized error lsf vector   */ 
                  Word16 *Pptr,      /* (o)  : predictor index              */ 
                  Word16 DOut,       /* (i)  : number of quantized vectors  */ 
                  Word16 *cluster,   /* (o)  : quantizer indices            */ 
                  Word16 *MS         /* (i)  : size of the quantizers       */ 
                  ); 
 
static void New_ML_search_1(Word16 *d_data,    /* (i) : error vector             */ 
                            Word16 J,          /* (i) : number of input vectors  */ 
                            Word16 *new_d_data,/* (o) : output vector            */ 
                            Word16 K,          /* (i) : number of candidates     */ 
                            Word16 *best_indx, /* (o) : best indices             */ 
                            Word16 *ptr_back,  /* (o) : pointer for backtracking */ 
                            Word16 *PtrTab,    /* (i) : quantizer table          */ 
                            Word16 MQ          /* (i) : size of quantizer        */ 
                            ); 
 
static void New_ML_search_2(Word16 *d_data,    /* (i) : error vector             */ 
                            Word16 *weight,    /* (i) : weighting vector         */ 
                            Word16 J,          /* (i) : number of input vectors  */ 
                            Word16 *new_d_data,/* (o) : output vector            */ 
                            Word16 K,          /* (i) : number of candidates     */ 
                            Word16 *best_indx, /* (o) : best indices             */ 
                            Word16 *ptr_prd,   /* (i) : pointer for backtracking */ 
                            Word16 *ptr_back,  /* (o) : pointer for backtracking */ 
                            Word16 PtrTab[2][16],/* (i) : quantizer table        */ 
                            Word16 MQ          /* (i) : size of quantizer        */ 
                            ); 
 
 
/*-----------------------------------------------------------------* 
 * Functions lsfq_noise                                            * 
 *           ~~~~~~~~~~                                            * 
 * Input:                                                          * 
 *   lsp[]         : unquantized lsp vector                        * 
 *   freq_prev[][] : memory of the lsf predictor                   * 
 *                                                                 * 
 * Output:                                                         * 
 *                                                                 * 
 *   lspq[]        : quantized lsp vector                          *  
 *   ana[]         : indices                                       * 
 *                                                                 * 
 *-----------------------------------------------------------------*/ 
void lsfq_noise(Word16 *lsp,  
                Word16 *lspq,  
                Word16 freq_prev[MA_NP][M],  
                Word16 *ana 
                ) 
{ 
  Word16 i, lsf[M], lsfq[M], weight[M], tmpbuf[M]; 
  Word16 MS[MODE]={32, 16}, Clust[MODE], mode, errlsf[M*MODE]; 
 
  /* convert lsp to lsf */ 
  Lsp_lsf2(lsp, lsf, M); 
 
  /* spacing to ~100Hz */ 
  if (lsf[0] < L_LIMIT) 
    lsf[0] = L_LIMIT; 
  for (i=0 ; i < M-1 ; i++) 
    if (sub(lsf[i+1], lsf[i]) < 2*GAP3)  
      lsf[i+1] = add(lsf[i], 2*GAP3); 
  if (lsf[M-1] > M_LIMIT) 
    lsf[M-1] = M_LIMIT; 
  if (lsf[M-1] < lsf[M-2])  
    lsf[M-2] = sub(lsf[M-1], GAP3); 
 
  /* get the lsf weighting */ 
  Get_wegt(lsf, weight); 
   
  /**********************/ 
  /* quantize the lsf's */ 
  /**********************/ 
   
  /* get the prediction error vector */ 
  for (mode=0; mode