cod_amr.c

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

#include "cod_amr.h"

#include "typedef.h"
#include "basic_op.h"
#include "lpc.h"
#include "cbsearch.h"
#include "gain_q.h"
#include "autocorr.h"
#include "vad.h"
#include "dtx_enc.h"
#include "ol_ltp.h"

#include "bitno_tab.h"


/* Spectral expansion factors */
static const Word16 gamma1[M] =
{
   30802, 28954, 27217, 25584, 24049,
   22606, 21250, 19975, 18777, 17650
};

/* gamma1 differs for the 12k2 coder */
static const Word16 gamma1_12k2[M] =
{
    29491, 26542, 23888, 21499, 19349,
    17414, 15672, 14105, 12694, 11425
};

static const Word16 gamma2[M] =
{
   19661, 11797, 7078, 4247, 2548,
   1529, 917, 550, 330, 198
};

/**************************************************************************

  Function    : cod_amr_init
  Purpose     : Allocates memory and initializes state variables
  Input         :
                    state : coding state pointer
                    dtx    : DTX flag
  Output      :
                   state : coding state pointer
  Retrun      :

***************************************************************************/
int cod_amr_init (cod_amrState **state, Flag dtx)
{
	cod_amrState* s;
	clLtpState* pClLtpState;
	Pitch_frState* pPitch_frState;

	lspState* plspState;
	Q_plsfState* pQ_plsfState;

	gainQuantState* pgainQuantState;
	gc_predState* pgc_predState, * pgc_predUnqState;
	GainAdaptState* pGainAdaptState;

	pitchOLWghtState* ppitchOLWghtState;
	tonStabState* ptonStabState;

#ifdef VAD2
	vadState2* pvadState2;
#else
	vadState1* pvadState1;	
#endif
	dtx_encState* pdtx_encState;

	lpcState* plpcState;
	LevinsonState* pLevinsonState;

  if (state == (cod_amrState **) NULL)
  {
      //fprintf(stderr, "cod_amr_init: invalid parameter\n");
      return -1;
   }
  *state = NULL;
 
  /* allocate memory */
  if ((s= (cod_amrState *) malloc(sizeof(cod_amrState))) == NULL)
  {
      //fprintf(stderr, "cod_amr_init: can not malloc state structure\n");
      return -1;
  }

  s->lpcSt = NULL;
  s->lspSt = NULL;
  s->clLtpSt = NULL;
  s->gainQuantSt = NULL;
  s->pitchOLWghtSt = NULL;
  s->tonStabSt = NULL;    
  s->vadSt = NULL;
  s->dtx_encSt = NULL;
  s->dtx = dtx;
  
    /* Init sub states */
    //    cl_ltp_init(&s->clLtpSt) ;
	

	
    if (&s->clLtpSt == (clLtpState **) NULL)
  {
        fprintf(stderr, "cl_ltp_init: invalid parameter\n");
        return -1;
    }
	
    s->clLtpSt = NULL;
    
    /* allocate memory */
    if ((pClLtpState= (clLtpState *) malloc(sizeof(clLtpState))) == NULL)
  {
        fprintf(stderr, "cl_ltp_init: can not malloc state structure\n");
        return -1;
  }
	
    /* init the sub state */
   if (&pClLtpState->pitchSt == (Pitch_frState **) NULL)
   {
        fprintf(stderr, "Pitch_fr_init: invalid parameter\n");
        return -1;
    }
   
    pClLtpState->pitchSt = NULL;

    /* allocate memory */
    if ((pPitch_frState = (Pitch_frState *) malloc(sizeof(Pitch_frState))) == NULL)
    {
        fprintf(stderr, "Pitch_fr_init: can not malloc state structure\n");	 
        return -1;
    }

    //Pitch_fr_reset(s);
    pPitch_frState->T0_prev_subframe = 0;	
pClLtpState->pitchSt = pPitch_frState;
  
    //cl_ltp_reset(pClLtpState);	

    s->clLtpSt = pClLtpState;
 
 // lsp_init(&s->lspSt);  
  if (&s->lspSt == (lspState **) NULL)
  {
      fprintf(stderr, "lsp_init: invalid parameter\n");
      return -1;
  }
  
  s->lspSt = NULL;
 
  /* allocate memory */
  if ((plspState= (lspState *) malloc(sizeof(lspState))) == NULL)
  {
      fprintf(stderr, "lsp_init: can not malloc state structure\n");
      return -1;
  }

  /* Initialize quantization state */
   //Q_plsf_init(&plspState->qSt);
  if (&plspState->qSt== (Q_plsfState **) NULL)
  {
      fprintf(stderr, "Q_plsf_init: invalid parameter\n");
      return -1;
  }
  plspState->qSt = NULL;
 
  /* allocate memory */
  if ((pQ_plsfState= (Q_plsfState *) malloc(sizeof(Q_plsfState))) == NULL)
  {
      fprintf(stderr, "Q_plsf_init: can not malloc state structure\n");
      return -1;
  }

  //Q_plsf_reset(pQ_plsfState);
 
  plspState->qSt = pQ_plsfState;
  
  /* Reset quantization state */
  // Q_plsf_reset(plspState->qSt);

 
   s->lspSt = plspState;
  //     gainQuant_init(&s->gainQuantSt) ;	 
  if (&s->gainQuantSt == (gainQuantState **) NULL){
      fprintf(stderr, "gainQuant_init: invalid parameter\n");
      return -1;
  }
  
  s->gainQuantSt = NULL;
 
  /* allocate memory */
  if ((pgainQuantState= (gainQuantState *) malloc(sizeof(gainQuantState))) == NULL)
  {
      fprintf(stderr, "gainQuant_init: can not malloc state structure\n");
      return -1;
  }
  
  pgainQuantState->gain_idx_ptr = NULL;
  
  pgainQuantState->gc_predSt = NULL;
  pgainQuantState->gc_predUnqSt = NULL;
  pgainQuantState->adaptSt = NULL;

  /* Init sub states */
 // gc_pred_init(&pgainQuantState->gc_predSt);
   if (&pgainQuantState->gc_predSt  == (gc_predState **) NULL)
  {
      fprintf(stderr, "gc_pred_init: invalid parameter\n");
      return -1;
  }
  
  pgainQuantState->gc_predSt  = NULL;

  /* allocate memory */
  if ((pgc_predState= (gc_predState *) malloc(sizeof(gc_predState))) == NULL)
 {
      fprintf(stderr, "gc_pred_init: can not malloc state structure\n");
      return -1;
  }
  //gc_pred_reset(pgc_predState);

  
  pgainQuantState->gc_predSt  = pgc_predState;

 /////////////
 
  //gc_pred_init(&pgainQuantState->gc_predUnqSt);
  

  if (&pgainQuantState->gc_predUnqSt== (gc_predState **) NULL)
  {
      fprintf(stderr, "gc_pred_init: invalid parameter\n");
      return -1;
  }
  
  pgainQuantState->gc_predUnqSt = NULL;

  /* allocate memory */
  if ((pgc_predUnqState= (gc_predState *) malloc(sizeof(gc_predState))) == NULL)
 {
      fprintf(stderr, "gc_pred_init: can not malloc state structure\n");
      return -1;
  }
  
    //gc_pred_reset(pgc_predUnqState);
  
      pgainQuantState->gc_predUnqSt = pgc_predUnqState;

  /////////////
  //gain_adapt_init(&pgainQuantState->adaptSt);


    if (&pgainQuantState->adaptSt == (GainAdaptState **) NULL)
    {
        fprintf(stderr, "gain_adapt_init: invalid parameter\n");
        return -1;
    }
	
    pgainQuantState->adaptSt = NULL;

    /* allocate memory */
    if ((pGainAdaptState = (GainAdaptState *) malloc(sizeof(GainAdaptState))) == NULL)
   {
        fprintf(stderr, "gain_adapt_init: can't malloc state structure\n");
        return -1;
    }
//	gain_adapt_reset(pGainAdaptState);


    pgainQuantState->adaptSt = pGainAdaptState;



  //gainQuant_reset(pgainQuantState);


  s->gainQuantSt= pgainQuantState;

    
    if (&s->pitchOLWghtSt == (pitchOLWghtState **) NULL)
   {
        fprintf(stderr, "p_ol_wgh_init: invalid parameter\n");
        return -1;
    }
	
   s->pitchOLWghtSt = NULL;
    
    /* allocate memory */
    if ((ppitchOLWghtState = (pitchOLWghtState *) malloc(sizeof(pitchOLWghtState))) == NULL)
   {
        fprintf(stderr, "p_ol_wgh_init: can not malloc state structure\n");
        return -1;
    }

 //p_ol_wgh_reset(ppitchOLWghtState);

 
   s->pitchOLWghtSt = ppitchOLWghtState;

   
    if (&s->tonStabSt == (tonStabState **) NULL){
        fprintf(stderr, "ton_stab_init: invalid parameter\n");
        return -1;
    }
	
    s->tonStabSt = NULL;
    
    /* allocate memory */
    if ((ptonStabState= (tonStabState *) malloc(sizeof(tonStabState))) == NULL){
        fprintf(stderr, "ton_stab_init: can not malloc state structure\n");
        return -1;
    }
    


     s->tonStabSt = ptonStabState;
      
#ifndef VAD2
//      vad1_init(&s->vadSt) ;

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

	s->vadSt = NULL;
    
    /* allocate memory */
    if ((pvadState1 = (vadState1 *) malloc(sizeof(vadState1))) == NULL)
   {
        fprintf(stderr, "vad_init: can not malloc state structure\n");
        return -1;
    }
    
    //vad1_reset(pvadState1);

    s->vadSt = pvadState1;


#else
   
	
    if (&s->vadSt == (vadState2 **) NULL){
        fprintf(stderr, "vad2_init: invalid parameter\n");
        return -1;
    }

	s->vadSt = NULL;
    
    /* allocate memory */
    if ((pvadState2 = (vadState2 *) malloc(sizeof(vadState2))) == NULL)
   {
        fprintf(stderr, "vad2_init: can not malloc state structure\n");
        return -1;
    }