qgain475.c

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

 19537,         5177,         19003,     3006,
 16454,         3788,         16070,     2367,
  8664,         2743,          9445,    26358,
 10856,         1287,          3555,     1009,
  5606,         3622,         19453,     5512,
 12453,          797,         20634,      911,
 15427,         3066,         17037,    10275,
 18883,         2633,          3913,     1268,
 19519,         3371,         18052,     5230,
 19291,         1678,         19508,     3172,
 18072,        10754,         16625,     6845,
  3134,         2298,         10869,     2437,
 15580,         6913,         12597,     3381,
 11116,         3297,         16762,     2424,
 18853,         6715,         17171,     9887,
 12743,         2605,          8937,     3140,
 19033,         7764,         18347,     3880,
 20475,         3682,         19602,     3380,
 13044,        19373,         10526,    23124
};


/*******************************************
Function:
Descrption:
Input:
	pred_st        :gain predictor state struct          
	p                   :pointer to selected quantizer table entry 
	gcode0         : predicted CB gain,     Q(14 - exp_gcode0) 
	exp_gcode0 : exponent of predicted CB gain,       
Output:
      gain_pit         : Pitch gain
      gain_cod       : Code gain
Return:

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

static void MR475_quant_store_results( gc_predState *pred_st, const Word16 *p,  Word16 gcode0, Word16 exp_gcode0,Word16 *gain_pit,  Word16 *gain_cod)
{
	Word16 g_code, exp, frac, tmp;
	Word32 L_tmp;

	Word16 qua_ener_MR122; /* o  : quantized energy error, MR122 version Q10 */
	Word16 qua_ener;            /* o  : quantized energy error,               Q10 */

	gc_predState *ppred_st = pred_st;
	Word16 *pgain_pit = gain_pit, *pgain_cod = gain_cod;
	const Word16*pp = p;
	
	/* Read the quantized gains */

	*pgain_pit   = *pp++;              
	 g_code       = *pp++;                 

	/*------------------------------------------------------------------*
	*  calculate final fixed codebook gain:                            *
	*  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~                            *
	*                                                                  *
	*   gc = gc0 * g                                                   *
	*------------------------------------------------------------------*/

	L_tmp = (g_code*gcode0 << 1);
	L_tmp =  (10 - exp_gcode0 ) > 0 ? L_tmp>>(10 -exp_gcode0) : L_tmp << -(10 -exp_gcode0) ;
	*pgain_cod = (Word16)(L_tmp >> 16);

	/*------------------------------------------------------------------*
	*  calculate predictor update values and update gain predictor:    *
	*  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    *
	*                                                                  *
	*   qua_ener       = log2(g)                                       *
	*   qua_ener_MR122 = 20*log10(g)                                   *
	*------------------------------------------------------------------*/

	Log2 ((g_code), &exp, &frac); /* Log2(x Q12) = log2(x) + 12 */

	exp -= 12 ;
	//tmp = shr_r (frac, 5);
	tmp = (frac>>5) + (((frac>>4)&0x1)!= 0);
	
	qua_ener_MR122 = tmp +(exp<< 10);
	L_tmp = (exp*49320) + ((24660*frac>>15)<<1);
	qua_ener = ((L_tmp<< 13) + 0x00008000)>>16;
	ppred_st->past_qua_en[3] = ppred_st->past_qua_en[2];           
	ppred_st->past_qua_en_MR122[3] = ppred_st->past_qua_en_MR122[2];
	ppred_st->past_qua_en[2] = ppred_st->past_qua_en[1];           
	ppred_st->past_qua_en_MR122[2] = ppred_st->past_qua_en_MR122[1];
	ppred_st->past_qua_en[1] = ppred_st->past_qua_en[0];           
	ppred_st->past_qua_en_MR122[1] = ppred_st->past_qua_en_MR122[0];

	ppred_st->past_qua_en_MR122[0] = qua_ener_MR122;  /*    log2 (qua_err), Q10 */
	ppred_st->past_qua_en[0] = qua_ener;     
}



/*************************************************************************
 *
 * FUNCTION:  MR475_update_unq_pred()
 *
 * PURPOSE:   use optimum codebook gain and update "unquantized"
 *            gain predictor with the (bounded) prediction error
 *
 *************************************************************************/
void MR475_update_unq_pred( gc_predState *pred_st,  Word16 exp_gcode0,  Word16 frac_gcode0, Word16 cod_gain_exp,Word16 cod_gain_frac )
{
    Word16 tmp, exp, frac;
    Word16 qua_ener, qua_ener_MR122;
    Word32 L_tmp;

    /* calculate prediction error factor (given optimum CB gain gcu):
     *
     *   predErrFact = gcu / gcode0
     *   (limit to MIN_PRED_ERR_FACT <= predErrFact <= MAX_PRED_ERR_FACT
     *    -> limit qua_ener*)
     *
     * calculate prediction error (log):
     *
     *   qua_ener_MR122 = log2(predErrFact)
     *   qua_ener       = 20*log10(predErrFact)
     *
     */

    if ( cod_gain_frac <= 0)
    {
        /* if gcu <= 0 -> predErrFact = 0 < MIN_PRED_ERR_FACT */
        /* -> set qua_ener(_MR122) directly                   */
        qua_ener = MIN_QUA_ENER;           
        qua_ener_MR122 = MIN_QUA_ENER_MR122; 
    }
    else
    {
        /* convert gcode0 from DPF to standard fraction/exponent format */
        /* with normalized frac, i.e. 16384 <= frac <= 32767            */
        /* Note: exponent correction (exp=exp-14) is done after div_s   */
		
        frac_gcode0 = (Word16)Pow2 (14, frac_gcode0);

        /* make sure cod_gain_frac < frac_gcode0  for div_s */
        if ( cod_gain_frac >=  frac_gcode0)
        {
            cod_gain_frac >>= 1;
            cod_gain_exp ++;
        }

        /*
          predErrFact
             = gcu / gcode0
             = cod_gain_frac/frac_gcode0 * 2^(cod_gain_exp-(exp_gcode0-14))
             = div_s (c_g_f, frac_gcode0)*2^-15 * 2^(c_g_e-exp_gcode0+14)
             = div_s * 2^(cod_gain_exp-exp_gcode0 - 1)
        */
        frac = div_s (cod_gain_frac, frac_gcode0);
		
        tmp = cod_gain_exp - exp_gcode0 - 1;

        Log2(frac, &exp, &frac);
        exp += tmp ;

        /* calculate prediction error (log2, Q10) */
        qua_ener_MR122 = shr_r (frac, 5);
		
        qua_ener_MR122 +=  (exp<<10);

        if ( qua_ener_MR122 < MIN_QUA_ENER_MR122)
        {
            qua_ener = MIN_QUA_ENER;            
            qua_ener_MR122 = MIN_QUA_ENER_MR122; 
        }
        else if ( qua_ener_MR122 >  MAX_QUA_ENER_MR122 )
        {
            qua_ener = MAX_QUA_ENER;            
            qua_ener_MR122 = MAX_QUA_ENER_MR122;
        }
        else
        {
            /* calculate prediction error (20*log10, Q10) */
	     L_tmp = (24660*exp<<1) + ((24660*frac>>15)<<1);
			
            /* 24660 Q12 ~= 6.0206 = 20*log10(2) */
			
            L_tmp = L_tmp >= (MAX_32 >>13) ? MAX_32 : L_tmp << 13;			
            qua_ener =  (L_tmp > 0 ) && ((L_tmp + 0x00008000) < 0) ? MAX_16 :  (L_tmp + 0x00008000) >>16;
			
            /* Q12 * Q0 = Q13 -> Q26 -> Q10     */
        }
    }

	/* update MA predictor memory */
	//    gc_pred_update(pred_st, qua_ener_MR122, qua_ener);

	pred_st->past_qua_en[3] = pred_st->past_qua_en[2];           
	pred_st->past_qua_en_MR122[3] = pred_st->past_qua_en_MR122[2]; 
	pred_st->past_qua_en[2] = pred_st->past_qua_en[1];           
	pred_st->past_qua_en_MR122[2] = pred_st->past_qua_en_MR122[1]; 
	pred_st->past_qua_en[1] = pred_st->past_qua_en[0];           
	pred_st->past_qua_en_MR122[1] = pred_st->past_qua_en_MR122[0]; 
	pred_st->past_qua_en_MR122[0] = qua_ener_MR122;  /*    log2 (qua_err), Q10 */	                                               
	pred_st->past_qua_en[0] = qua_ener;              /* 20*log10(qua_err), Q10 */
	                                                          
}


/*************************************************************************
 
 Function   :  MR475_gain_quant() 
 Purpose: Quantization of pitch and codebook gains for two subframes
          (using predicted codebook gain)
 
Input:
	pred_s                 : gain predictor state struct      
	sf0_exp_gcode0 : predicted CB gain (exponent),      Q0
	sf0_frac_gcode0: predicted CB gain (fraction),      Q15
	sf0_exp_coeff[] : energy coeff. (5), exponent part,  Q0
	sf0_frac_coeff[  : energy coeff. (5), fraction part,  Q15 
	sf0_exp_target_en  : exponent of target energy,         Q0  
	f0_frac_target_en   :  fraction of target energy,         Q15


	sf1_code_nosharp[] : innovative codebook vector (L_SUBFR)   
	f1_exp_gcode0         : predicted CB gain (exponent),      Q0  
	sf1_frac_gcode0       : predicted CB gain (fraction),      Q15 
	sf1_exp_coeff[]        : energy coeff. (5), exponent part,  Q0  
	sf1_frac_coeff[]       : energy coeff. (5), fraction part,  Q15
	sf1_exp_target_en   : exponent of target energy,         Q0  
	sf1_frac_target_en  : fraction of target energy,         Q15 
	gp_limit                     : pitch gain limit         
   
Output:

	sf0_gain_pit             : Pitch gain,                        Q14
	sf0_gain_cod           : Code gain,                         Q1  
	sf1_gain_pit             : Pitch gain,                        Q14
	sf1_gain_cod            : Code gain,                         Q1
	
Return:
      index of Quantization

 *************************************************************************/
Word16
MR475_gain_quant(  gc_predState *pred_st,   Word16 sf0_exp_gcode0, Word16 sf0_frac_gcode0,   Word16 sf0_exp_coeff[], Word16 sf0_frac_coeff[],  
    Word16 sf0_exp_target_en,  Word16 sf0_frac_target_en,  Word16 sf1_code_nosharp[],Word16 sf1_exp_gcode0,    
    Word16 sf1_frac_gcode0, Word16 sf1_exp_coeff[], Word16 sf1_frac_coeff[], Word16 sf1_exp_target_en, 
    Word16 sf1_frac_target_en,  Word16 gp_limit,  Word16 *sf0_gain_pit, Word16 *sf0_gain_cod,  Word16 *sf1_gain_pit,   Word16 *sf1_gain_cod )
{
    const Word16 *p;
    Word16 i, index = 0;
    Word16 tmp;
    Word16 exp;
    Word16 sf0_gcode0, sf1_gcode0;
    Word16 g_pitch, g2_pitch, g_code, g2_code, g_pit_cod;
    Word16 coeff[10], coeff_lo[10], exp_max[10];  /* 0..4: sf0; 5..9: sf1 */
    Word32 L_tmp, dist_min;

    /*-------------------------------------------------------------------*
     *  predicted codebook gain                                          *
     *  ~~~~~~~~~~~~~~~~~~~~~~~                                          *
     *  gc0     = 2^exp_gcode0 + 2^frac_gcode0                           *
     *                                                                   *
     *  gcode0 (Q14) = 2^14*2^frac_gcode0 = gc0 * 2^(14-exp_gcode0)      *
     *-------------------------------------------------------------------*/

    sf0_gcode0 = (Word16)Pow2(14, sf0_frac_gcode0);
    sf1_gcode0 = (Word16)Pow2(14, sf1_frac_gcode0);

    /*