update_freq_prev(state->lsp_s.freq_prev, (const FLOAT (*)[M]) lsfq_mem);	  state->ppastVad = state->pastVad;	  state->pastVad = Vad;	  /* Update wsp, mem_w and mem_w0 */	  Aq = Aq_t;	  for (i_subfr=0; i_subfr < L_FRAME; i_subfr += L_SUBFR)	  {		/* Residual signal in xn */		residu(Aq, &state->speech[i_subfr], xn, L_SUBFR);    		weight_az(Aq, GAMMA1, M, Ap_t);    		/* Compute wsp and mem_w */		Ap = Ap_t + MP1;		Ap[0] = 0.125;		for (i=1; i<=M; i++)    /* Ap[i] = Ap_t[i] - 0.7 * Ap_t[i-1]; */		  Ap[i] = (F)(Ap_t[i] - 0.7 * Ap_t[i-1]);		syn_filt(Ap, xn, &state->wsp[i_subfr], L_SUBFR, state->mem_w, 1);    		/* Compute mem_w0 */		for (i=0; i<L_SUBFR; i++) {		  xn[i] = xn[i] - state->exc[i_subfr+i];  /* residu[] - exc[] */		}		syn_filt(Ap_t, xn, xn, L_SUBFR, state->mem_w0, 1);            		Aq += MP1;	  }  	  state->sharp = SHARPMIN;  	  /* Update memories for next frames */	  copy(&state->old_speech[L_FRAME], &state->old_speech[0], L_TOTAL-L_FRAME);	  copy(&state->old_wsp[L_FRAME], &state->old_wsp[0], PIT_MAX);	  copy(&state->old_exc[L_FRAME], &state->old_exc[0], PIT_MAX+L_INTERPOL);  	  return;	}  /* End of inactive frame case */	/* -------------------- */	/* Case of Active frame */	/* -------------------- */    	*ana++ = 1;	state->seed = INIT_SEED;	state->ppastVad = state->pastVad;	state->pastVad = Vad;     /* LSP quantization */     qua_lsp(&state->lsp_s, lsp_new, lsp_new_q, ana);     ana += 2;                        /* Advance analysis parameters pointer */    /*--------------------------------------------------------------------*     * Find interpolated LPC parameters in all subframes                  *     * The interpolated parameters are in array Aq_t[].                   *     *--------------------------------------------------------------------*/    int_qlpc(state->lsp_old_q, lsp_new_q, Aq_t);    /* Compute A(z/gamma) */    weight_az(&Aq_t[0],   GAMMA1, M, &Ap_t[0]);    weight_az(&Aq_t[MP1], GAMMA1, M, &Ap_t[MP1]);    /* update the LSPs for the next frame */    copy(lsp_new,   state->lsp_old,   M);    copy(lsp_new_q, state->lsp_old_q, M);  }   /*----------------------------------------------------------------------*    * - Find the weighted input speech w_sp[] for the whole speech frame   *    * - Find the open-loop pitch delay for the whole speech frame          *    * - Set the range for searching closed-loop pitch in 1st subframe      *    *----------------------------------------------------------------------*/   residu(&Aq_t[0],   &state->speech[0],       &state->exc[0],       L_SUBFR);   residu(&Aq_t[MP1], &state->speech[L_SUBFR], &state->exc[L_SUBFR], L_SUBFR);  {     FLOAT Ap1[MP1];     Ap = Ap_t;     Ap1[0] = (F)1.0;     for(i=1; i<=M; i++)       Ap1[i] = Ap[i] - (F)0.7 * Ap[i-1];     syn_filt(Ap1, &state->exc[0], &state->wsp[0], L_SUBFR, state->mem_w, 1);     Ap += MP1;     for(i=1; i<=M; i++)       Ap1[i] = Ap[i] - (F)0.7 * Ap[i-1];     syn_filt(Ap1, &state->exc[L_SUBFR], &state->wsp[L_SUBFR], L_SUBFR, state->mem_w, 1);   }   /* Find open loop pitch lag for whole speech frame */   T_op = pitch_ol_fast(state->wsp, L_FRAME);   /* Range for closed loop pitch search in 1st subframe */   T0_min = T_op - 3;   if (T0_min < PIT_MIN) T0_min = PIT_MIN;   T0_max = T0_min + 6;   if (T0_max > PIT_MAX)   {      T0_max = PIT_MAX;      T0_min = T0_max - 6;   }   /*------------------------------------------------------------------------*    *          Loop for every subframe in the analysis frame                 *    *------------------------------------------------------------------------*    *  To find the pitch and innovation parameters. The subframe size is     *    *  L_SUBFR and the loop is repeated L_FRAME/L_SUBFR times.               *    *     - find the weighted LPC coefficients                               *    *     - find the LPC residual signal                                     *    *     - compute the target signal for pitch search                       *    *     - compute impulse response of weighted synthesis filter (h1[])     *    *     - find the closed-loop pitch parameters                            *    *     - encode the pitch delay                                           *    *     - find target vector for codebook search                           *    *     - codebook search                                                  *    *     - VQ of pitch and codebook gains                                   *    *     - update states of weighting filter                                *    *------------------------------------------------------------------------*/   Aq = Aq_t;    /* pointer to interpolated quantized LPC parameters */   Ap = Ap_t;    /* pointer to weighted LPC coefficients             */   for (i_subfr = 0;  i_subfr < L_FRAME; i_subfr += L_SUBFR)   {      /*---------------------------------------------------------------*       * Compute impulse response, h1[], of weighted synthesis filter  *       *---------------------------------------------------------------*/      h1[0] = (F)1.0;      set_zero(&h1[1], L_SUBFR-1);      syn_filt(Ap, h1, h1, L_SUBFR, &h1[1], 0);      /*-----------------------------------------------*       * Find the target vector for pitch search:      *       *----------------------------------------------*/      syn_filt(Ap, &state->exc[i_subfr], xn, L_SUBFR, state->mem_w0, 0);      /*-----------------------------------------------------------------*       *    Closed-loop fractional pitch search                          *       *-----------------------------------------------------------------*/      T0 = pitch_fr3_fast(&state->exc[i_subfr], xn, h1, L_SUBFR, T0_min, T0_max,                    i_subfr, &T0_frac);      index = enc_lag3(T0, T0_frac, &T0_min, &T0_max, PIT_MIN, PIT_MAX,                            i_subfr);      *ana++ = index;      if (i_subfr == 0)        *ana++ = parity_pitch(index);      /*-----------------------------------------------------------------*       *   - find filtered pitch exc                                     *       *   - compute pitch gain and limit between 0 and 1.2              *       *   - update target vector for codebook search                    *       *   - find LTP residual.                                          *       *-----------------------------------------------------------------*/      syn_filt(Ap, &state->exc[i_subfr], y1, L_SUBFR, state->mem_zero, 0);      gain_pit = g_pitch(xn, y1, g_coeff, L_SUBFR);      /* clip pitch gain if taming is necessary */      taming = test_err(state->cng_s.exc_err, T0, T0_frac);      if( taming == 1){        if (gain_pit > GPCLIP) {          gain_pit = GPCLIP;      }    }    for (i = 0; i < L_SUBFR; i++)        xn2[i] = xn[i] - y1[i]*gain_pit;      /*-----------------------------------------------------*       * - Innovative codebook search.                       *       *-----------------------------------------------------*/      index = ACELP_code_A(xn2, h1, T0, state->sharp, code, y2, &i);      *ana++ = index;           /* Positions index */      *ana++ = i;               /* Signs index     */      /*------------------------------------------------------*       *  - Compute the correlations <y2,y2>, <xn,y2>, <y1,y2>*       *  - Vector quantize gains.                            *       *------------------------------------------------------*/      corr_xy2(xn, y1, y2, g_coeff);      *ana++ = qua_gain(&state->gain_s, code, g_coeff, L_SUBFR, &gain_pit, &gain_code,                                    taming);      /*------------------------------------------------------------*       * - Update pitch sharpening "sharp" with quantized gain_pit  *       *------------------------------------------------------------*/      state->sharp = gain_pit;      if (state->sharp > SHARPMAX) state->sharp = SHARPMAX;      if (state->sharp < SHARPMIN) state->sharp = SHARPMIN;      /*------------------------------------------------------*       * - Find the total excitation                          *       * - update filters' memories for finding the target    *       *   vector in the next subframe  (mem_w0[])            *       *------------------------------------------------------*/      for (i = 0; i < L_SUBFR;  i++)        state->exc[i+i_subfr] = gain_pit*state->exc[i+i_subfr] + gain_code*code[i];      update_exc_err(state->cng_s.exc_err, gain_pit, T0);      for (i = L_SUBFR-M, j = 0; i < L_SUBFR; i++, j++)        state->mem_w0[j]  = xn[i] - gain_pit*y1[i] - gain_code*y2[i];      Aq += MP1;           /* interpolated LPC parameters for next subframe */      Ap += MP1;   }   /*--------------------------------------------------*    * Update signal for next frame.                    *    * -> shift to the left by L_FRAME:                 *    *     speech[], wsp[] and  exc[]                   *    *--------------------------------------------------*/   copy(&state->old_speech[L_FRAME], &state->old_speech[0], L_TOTAL-L_FRAME);   copy(&state->old_wsp[L_FRAME], &state->old_wsp[0], PIT_MAX);   copy(&state->old_exc[L_FRAME], &state->old_exc[0], PIT_MAX+L_INTERPOL);}