cod_amr.c

AMR-NB 的编码实现,纯C, VC下建立工程即可用.

  
   s->vadSt = pvadState2;

#endif

//      dtx_enc_init(&s->dtx_encSt) ;

 
  if (&s->dtx_encSt == (dtx_encState **) NULL){
    fprintf(stderr, "dtx_enc_init: invalid parameter\n");
    return -1;
  }
  
  s->dtx_encSt = NULL;
 
  /* allocate memory */
  if ((pdtx_encState= (dtx_encState *) malloc(sizeof(dtx_encState))) == NULL){
    fprintf(stderr, "dtx_enc_init: can not malloc state structure\n");
    return -1;
  }
  
   //dtx_enc_reset(pdtx_encState);



  s->dtx_encSt = pdtx_encState;

 
  if (&s->lpcSt == (lpcState **) NULL){
      fprintf(stderr, "lpc_init: invalid parameter\n");
      return -1;
  }

  s->lpcSt = NULL;
 
  /* allocate memory */
  if ((plpcState = (lpcState *) malloc(sizeof(lpcState))) == NULL)
  {
      fprintf(stderr, "lpc_init: can not malloc state structure\n");
      return -1;
  }
  
  plpcState->levinsonSt = NULL;
  
  /* Init sub states */
  
  if (&plpcState->levinsonSt == (LevinsonState **) NULL)
  {
      fprintf(stderr, "Levinson_init: invalid parameter\n");
      return -1;
  }

  plpcState->levinsonSt = NULL;
 
  /* allocate memory */
  if ((pLevinsonState = (LevinsonState *) malloc(sizeof(LevinsonState))) == NULL)
  {
      fprintf(stderr, "Levinson_init: can not malloc state structure\n");
      return -1;
  }
  
//  Levinson_reset(pLevinsonState);

  pLevinsonState->old_A[0] = 4096;
  memset(&pLevinsonState->old_A[1], 0, M*sizeof(Word16));

  plpcState->levinsonSt = pLevinsonState;


  s->lpcSt = plpcState;
  
  cod_amr_reset(s);
  
  *state = s;

    return 0;



}

int cod_amr_reset (cod_amrState *st)
{
#ifdef VAD2
       Word16	*ptr;
#endif
	if (st == (cod_amrState *) NULL)
	{
		fprintf(stderr, "cod_amr_reset: invalid parameter\n");
		return -1;
	}
  
	/*-----------------------------------------------------------------------*
	*          Initialize pointers to speech vector.                        *
	*-----------------------------------------------------------------------*/

	st->new_speech = st->old_speech + L_TOTAL - L_FRAME;   /* New speech     */
	st->speech = st->new_speech - L_NEXT;                            /* Present frame  */
	st->p_window = st->old_speech + L_TOTAL - L_WINDOW;    /* For LPC window */
	st->p_window_12k2 = st->p_window - L_NEXT;                   /* EFR LPC window: no lookahead */

	/* Initialize static pointers */

	st->wsp = st->old_wsp + PIT_MAX;
	st->exc = st->old_exc + PIT_MAX + L_INTERPOL;
	st->zero = st->ai_zero + MP1;
	st->error = st->mem_err + M;
	st->h1 = &st->hvec[L_SUBFR];
   
	/* Static vectors to zero */
   
	memset(st->old_speech, 0, L_TOTAL*sizeof(Word16));
	memset(st->old_exc, 0, (PIT_MAX + L_INTERPOL)*sizeof(Word16));
	memset(st->old_wsp, 0, PIT_MAX *sizeof(Word16));
	memset(st->mem_syn, 0, M*sizeof(Word16));
	memset(st->mem_w, 0, M*sizeof(Word16));
	memset(st->mem_w0, 0, M*sizeof(Word16));
	memset(st->mem_err, 0, M*sizeof(Word16));
	memset(st->zero, 0, L_SUBFR*sizeof(Word16));
	memset(st->hvec, 0, L_SUBFR*sizeof(Word16));

	/* OL LTP states */
	//  for (i = 0; i < 5; i++)
	st->old_lags[0] = st->old_lags[1] = st->old_lags[2] = st->old_lags[3] =  st->old_lags[4] = 40;

	/* Reset lpc states */
	// lpc_reset(st->lpcSt);

	st->lpcSt->levinsonSt->old_A[0] = 4096;
	memset(&st->lpcSt->levinsonSt->old_A[1], 0, M*sizeof(Word16));


	/* Reset lsp states */
	// lsp_reset(st->lspSt);


	/* Init lsp_old[] */
	// Copy(lsp_init_data, &st->lspSt->lsp_old[0], M);
	st->lspSt->lsp_old[0] = lsp_init_data[0];  st->lspSt->lsp_old[1] = lsp_init_data[1];
	st->lspSt->lsp_old[2] = lsp_init_data[2];  st->lspSt->lsp_old[3] = lsp_init_data[3];
	st->lspSt->lsp_old[4] = lsp_init_data[4];  st->lspSt->lsp_old[5] = lsp_init_data[5];
	st->lspSt->lsp_old[6] = lsp_init_data[6];  st->lspSt->lsp_old[7] = lsp_init_data[7];
	st->lspSt->lsp_old[8] = lsp_init_data[8];  st->lspSt->lsp_old[9] = lsp_init_data[9];


	/* Initialize lsp_old_q[] */
	//Copy(st->lspSt->lsp_old, st->lspSt->lsp_old_q, M);
	st->lspSt->lsp_old_q[0] = st->lspSt->lsp_old[0];  st->lspSt->lsp_old_q[1] = st->lspSt->lsp_old[1]; 
	st->lspSt->lsp_old_q[2] = st->lspSt->lsp_old[2];  st->lspSt->lsp_old_q[3] = st->lspSt->lsp_old[3]; 
	st->lspSt->lsp_old_q[4] = st->lspSt->lsp_old[4];  st->lspSt->lsp_old_q[5] = st->lspSt->lsp_old[5]; 
	st->lspSt->lsp_old_q[6] = st->lspSt->lsp_old[6];  st->lspSt->lsp_old_q[7] = st->lspSt->lsp_old[7]; 
	st->lspSt->lsp_old_q[8] = st->lspSt->lsp_old[8];  st->lspSt->lsp_old_q[9] = st->lspSt->lsp_old[9]; 

	/* Reset quantization state */
	// Q_plsf_reset(st->lspSt->qSt);

	//  for ( i = 0; i < M; i++)
	memset( st->lspSt->qSt->past_rq, 0, M*sizeof(Word16));


	/* Reset clLtp states */
	// cl_ltp_reset(st->clLtpSt);
	st->clLtpSt->pitchSt->T0_prev_subframe = 0;


	//gainQuant_reset(st->gainQuantSt);
	st->gainQuantSt->sf0_exp_gcode0 = 0;
	st->gainQuantSt->sf0_frac_gcode0 = 0;
	st->gainQuantSt->sf0_exp_target_en = 0;
	st->gainQuantSt->sf0_frac_target_en = 0;

	//Set_zero (st->gainQuantSt->sf0_exp_coeff, 5);
	memset(st->gainQuantSt->sf0_exp_coeff, 0, 5*sizeof(Word16));
	// Set_zero (st->gainQuantSt->sf0_frac_coeff, 5);
	memset(st->gainQuantSt->sf0_frac_coeff, 0, 5*sizeof(Word16));

	st->gainQuantSt->gain_idx_ptr = NULL;


	//gc_pred_reset(st->gainQuantSt->gc_predSt);
	//gc_pred_reset(st->gainQuantSt->gc_predUnqSt);

	st->gainQuantSt->gc_predSt->past_qua_en[0] = st->gainQuantSt->gc_predSt->past_qua_en[1] =
	st->gainQuantSt->gc_predSt->past_qua_en[2] = st->gainQuantSt->gc_predSt->past_qua_en[3] = 

	st->gainQuantSt->gc_predUnqSt->past_qua_en[0] = st->gainQuantSt->gc_predUnqSt->past_qua_en[1] =
	st->gainQuantSt->gc_predUnqSt->past_qua_en[2] = st->gainQuantSt->gc_predUnqSt->past_qua_en[3] =  -14336;

	st->gainQuantSt->gc_predSt->past_qua_en_MR122[0] = st->gainQuantSt->gc_predSt->past_qua_en_MR122[1] = 
	st->gainQuantSt->gc_predSt->past_qua_en_MR122[2] = st->gainQuantSt->gc_predSt->past_qua_en_MR122[3] = 

	st->gainQuantSt->gc_predUnqSt->past_qua_en_MR122[0] = st->gainQuantSt->gc_predUnqSt->past_qua_en_MR122[1] = 
	st->gainQuantSt->gc_predUnqSt->past_qua_en_MR122[2] = st->gainQuantSt->gc_predUnqSt->past_qua_en_MR122[3] = -2381;




	// gain_adapt_reset(st->gainQuantSt->adaptSt);
	st->gainQuantSt->adaptSt->onset = 0;
	st->gainQuantSt->adaptSt->prev_alpha = 0;
	st->gainQuantSt->adaptSt->prev_gc = 0;

	memset(st->gainQuantSt->adaptSt->ltpg_mem, 0, LTPG_MEM_SIZE*sizeof(Word16));


	///////////
	//   p_ol_wgh_reset(st->pitchOLWghtSt);
	/* Reset pitch search states */
	st->pitchOLWghtSt->old_T0_med = 40;
	st->pitchOLWghtSt->ada_w = 0;
	st->pitchOLWghtSt->wght_flg = 0; 

	// ton_stab_reset(st->tonStabSt);  

	/* initialize tone stabilizer state */ 
	st->tonStabSt->count = 0;
	memset(st->tonStabSt->gp, 0, N_FRAME*sizeof(Word16));    /* Init Gp_Clipping */

#ifndef VAD2

	//   vad1_reset(st->vadSt);
	/* Initialize pitch detection variables */
	st->vadSt->oldlag_count = 0;
	st->vadSt->oldlag = 0;         
	st->vadSt->pitch = 0;
	st->vadSt->tone = 0;            

	st->vadSt->complex_high = 0;            
	st->vadSt->complex_low = 0;            
	st->vadSt->complex_hang_timer = 0;

	st->vadSt->vadreg = 0;         

	st->vadSt->stat_count = 0;    
	st->vadSt->burst_count = 0;    
	st->vadSt->hang_count = 0;     
	st->vadSt->complex_hang_count = 0;     

	/* initialize memory used by the filter bank */
	
	st->vadSt->a_data5[0][0] = 
	st->vadSt->a_data5[0][1] =
	st->vadSt->a_data5[1][0] =
	st->vadSt->a_data5[1][1] =
	st->vadSt->a_data5[2][0] =
	st->vadSt->a_data5[2][1] = 0;

	memset(st->vadSt->a_data3, 0, 5*sizeof(Word16));

	/* initialize the rest of the memory */
	
	st->vadSt->bckr_est[0] =  st->vadSt->old_level[0] =  st->vadSt->ave_level[0] =  
	st->vadSt->bckr_est[1] =  st->vadSt->old_level[1] =  st->vadSt->ave_level[1] =
	st->vadSt->bckr_est[2] =  st->vadSt->old_level[2] =  st->vadSt->ave_level[2] =
	st->vadSt->bckr_est[3] =  st->vadSt->old_level[3] =  st->vadSt->ave_level[3] =
	st->vadSt->bckr_est[4] =  st->vadSt->old_level[4] =  st->vadSt->ave_level[4] =
	st->vadSt->bckr_est[5] =  st->vadSt->old_level[5] =  st->vadSt->ave_level[5] =
	st->vadSt->bckr_est[6] =  st->vadSt->old_level[6] =  st->vadSt->ave_level[6] =
	st->vadSt->bckr_est[7] =  st->vadSt->old_level[7] =  st->vadSt->ave_level[7] =
	st->vadSt->bckr_est[8] =  st->vadSt->old_level[8] =  st->vadSt->ave_level[8] = NOISE_INIT;

	memset(st->vadSt->sub_level, 0, COMPLEN*sizeof(Word16));
	
	st->vadSt->best_corr_hp = CVAD_LOWPOW_RESET; 

	st->vadSt->speech_vad_decision = 0;
	st->vadSt->complex_warning = 0;
	st->vadSt->sp_burst_count = 0;        

	st->vadSt->corr_hp_fast = CVAD_LOWPOW_RESET;


#else
	//vad2_reset(st->vadSt);
	ptr = (Word16 *)(st->vadSt);
	memset(ptr, 0, sizeof(vadState2));

#endif 

	dtx_enc_reset(st->dtx_encSt);
	st->sharp = SHARPMIN;
	return 0;
	
}
 
/*
**************************************************************************
*
*  Function    : cod_amr_exit
*  Purpose     : The memory used for state memory is freed
*
**************************************************************************
*/
void cod_amr_exit (cod_amrState **state)
{


	if (state == NULL || *state == NULL)
		return;

	/* dealloc members */
	// lpc_exit(&(*state)->lpcSt);

	if (&(*state)->lpcSt == NULL || (*state)->lpcSt == NULL)
		return;
	// Levinson_exit(&(*state)->levinsonSt);
	if (&((*state)->lpcSt)->levinsonSt == NULL ||((*state)->lpcSt)->levinsonSt == NULL)
		return;

	/* deallocate memory */
	free(((*state)->lpcSt)->levinsonSt);
	((*state)->lpcSt)->levinsonSt = NULL;

	/* deallocate memory */
	free((*state)->lpcSt);
	(*state)->lpcSt = NULL;

	//   lsp_exit(&(*state)->lspSt);
	if (&(*state)->lspSt == NULL || (*state)->lspSt == NULL)
		return;

	/* Deallocate members */
	//Q_plsf_exit(&(*st)->qSt);
	if (&((*state)->lspSt)->qSt == NULL || ((*state)->lspSt)->qSt == NULL)
		return;

	/* deallocate memory */
	free(((*state)->lspSt)->qSt);
	((*state)->lspSt)->qSt = NULL;

	/* deallocate memory */
	free((*state)->lspSt);
	(*state)->lspSt = NULL;

//	   gainQuant_exit(&(*state)->gainQuantSt);
	if (&(*state)->gainQuantSt == NULL || (*state)->gainQuantSt == NULL)
		return;

	// gc_pred_exit(&(*state)->gc_predSt);
	if (&((*state)->gainQuantSt)->gc_predSt== NULL || ((*state)->gainQuantSt)->gc_predSt == NULL)
		return;

	/* deallocate memory */
	free(((*state)->gainQuantSt)->gc_predSt);
	((*state)->gainQuantSt)->gc_predSt = NULL;

	//gc_pred_exit(&(*state)->gc_predUnqSt);
	if (&((*state)->gainQuantSt)->gc_predUnqSt == NULL || ((*state)->gainQuantSt)->gc_predUnqSt == NULL)
		return;

	/* deallocate memory */
	free(((*state)->gainQuantSt)->gc_predUnqSt);
	((*state)->gainQuantSt)->gc_predUnqSt = NULL;

	if ( &((*state)->gainQuantSt)->adaptSt == NULL || ((*state)->gainQuantSt)->adaptSt == NULL)
		return;

	/* deallocate memory */
	free( ((*state)->gainQuantSt)->adaptSt);