g_pitch.c

君正早期ucos系统(只有早期的才不没有打包成库),MPLAYER,文件系统,图片解码,浏览,电子书,录音,想学ucos,识货的人就下吧 russblock fmradio explore set

/*
********************************************************************************
*
*      GSM AMR-NB speech codec   R98   Version 7.6.0   December 12, 2001
*                                R99   Version 3.3.0                
*                                REL-4 Version 4.1.0                
*
********************************************************************************
*
*      File             : g_pitch.c
*      Purpose          : Compute the pitch (adaptive codebook) gain.
*
********************************************************************************
*/
/*
********************************************************************************
*                         MODULE INCLUDE FILE AND VERSION ID
********************************************************************************
*/
#include "g_pitch.h"
const char g_pitch_id[] = "@(#)$Id $" g_pitch_h;
 
/*
********************************************************************************
*                         INCLUDE FILES
********************************************************************************
*/
#include <uclib.h>
#include <uclib.h>
#include "typedef.h"
#include "mode.h"
#include "basic_op.h"
#include "oper_32b.h"
#include "count.h"
#include "cnst.h"
//add for jzmedia accerative instruction sets
#ifdef JZ4740_MXU_OPT
#include "jzmedia.h"
#endif

 
/*
********************************************************************************
*                         PUBLIC PROGRAM CODE
********************************************************************************
*/
/*************************************************************************
 *
 *  FUNCTION:  G_pitch
 *
 *  PURPOSE:  Compute the pitch (adaptive codebook) gain.
 *            Result in Q14 (NOTE: 12.2 bit exact using Q12) 
 *
 *  DESCRIPTION:
 *      The adaptive codebook gain is given by
 *
 *              g = <x[], y[]> / <y[], y[]>
 *
 *      where x[] is the target vector, y[] is the filtered adaptive
 *      codevector, and <> denotes dot product.
 *      The gain is limited to the range [0,1.2] (=0..19661 Q14)
 *
 *************************************************************************/
Word16 G_pitch     (    /* o : Gain of pitch lag saturated to 1.2       */
    enum Mode mode,     /* i : AMR mode                                 */
    Word16 xn[],        /* i : Pitch target.                            */
    Word16 y1[],        /* i : Filtered adaptive codebook.              */
    Word16 g_coeff[],   /* i : Correlations need for gain quantization  */
    Word16 L_subfr      /* i : Length of subframe.                      */
)
{
    Word16 i;
    Word16 xy, yy, exp_xy, exp_yy, gain;
    Word32 s;

    Word16 scaled_y1[L_SUBFR];   /* Usually dynamic allocation of (L_subfr) */

#ifdef JZ4740_MXU_OPT
#define  ADD_MASK 0xFFFFFFFC
#define  REF_MASK 0x03
    Word16 *ptr1, *ptr2;
    Word32 ref1, ref2;

    ptr1 = (unsigned int)(y1 - 2) & ADD_MASK;
    ref1 = 4 - (unsigned int)y1 & REF_MASK;
    ptr2 = scaled_y1 - 2;
    Q16ADD_AA_WW(xr10, xr0,xr0,xr11);  //s = 0;
    S32LDI(xr12, ptr1, 0x04);
    for( i = 0; i < L_subfr / 2; i++){
       S32LDI(xr1, ptr1, 0x04);
       S32ALN(xr3, xr12, xr1, ref1);
       Q16ADD_AA_WW(xr12,xr1, xr0,xr0);
       Q16SLR(xr2, xr3,xr0,xr0, 2);
       S32SDI(xr2, ptr2, 0x04);
       D16MAC_AA_WW(xr10, xr3,xr3,xr11);
    }
    D32SLL(xr3, xr10, xr11,xr4, 1);
    D32ADD_AA(xr1, xr3, xr4,xr2);
    s = S32M2I(xr1) + 1;
    Overflow = 0; 
    if( s < 0)
       Overflow = 1;
    
#else
    /* divide "y1[]" by 4 to avoid overflow */

    for (i = 0; i < L_subfr; i++)
    {
        scaled_y1[i] = shr (y1[i], 2); //move16 (); 
    }

    /* Compute scalar product <y1[],y1[]> */

    /* Q12 scaling / MR122 */
    Overflow = 0;                   //move16 ();
    s = 1L;                         //move32 (); /* Avoid case of all zeros */
    for (i = 0; i < L_subfr; i++)
    {
        s = L_mac (s, y1[i], y1[i]);
    }
#endif
    //test (); 
    if (Overflow == 0)       /* Test for overflow */
    {
        exp_yy = norm_l (s);
        yy = round (L_shl (s, exp_yy));
    }
    else
    {
#ifdef JZ4740_MXU_OPT
        ptr2 = scaled_y1 - 2;

        Q16ADD_AA_WW(xr10, xr0,xr0,xr11);  //s = 0;
        for( i = 0; i < L_subfr / 2; i++){
           S32LDI(xr2, ptr2, 0x04);
           D16MAC_AA_WW(xr10, xr2,xr2,xr11);
        }
        D32SLL(xr3, xr10, xr11,xr4, 1);
        D32ADD_AA(xr1, xr3, xr4,xr2);
        s = S32M2I(xr1) + 1;
#else 
        s = 1L;                     //move32 (); /* Avoid case of all zeros */
        for (i = 0; i < L_subfr; i++)
        {
            s = L_mac (s, scaled_y1[i], scaled_y1[i]);
        }
#endif
        exp_yy = norm_l (s);
        yy = round (L_shl (s, exp_yy));
        exp_yy = sub (exp_yy, 4);
    }
        
    /* Compute scalar product <xn[],y1[]> */
        
    Overflow = 0;                   //move16 (); 
    s = 1L;                         //move32 (); /* Avoid case of all zeros */
 
#ifdef JZ4740_MXU_OPT

    ptr1 = (unsigned int)(y1 - 2) & ADD_MASK;
    ref1 = 4 - (unsigned int)y1 & REF_MASK;
    ptr2 = (unsigned int)(xn - 2) & ADD_MASK;
    ref2 = 4 - (unsigned int)xn & REF_MASK;
    Q16ADD_AA_WW(xr10, xr0,xr0,xr11);  //s = 0;
    S32LDI(xr12, ptr1, 0x04);
    S32LDI(xr13, ptr2, 0x04);
    for( i = 0; i < L_subfr / 2; i++){
       S32LDI(xr1, ptr1, 0x04);
       S32ALN(xr3, xr12, xr1, ref1);
       S32LDI(xr2, ptr2, 0x04);
       S32ALN(xr4, xr13, xr2, ref2);
       Q16SLL(xr12,xr1, xr2,xr13,0);
       D16MAC_AA_WW(xr10, xr3,xr4,xr11);
    }
    D32SLL(xr3, xr10, xr11,xr4, 1);
    D32ADD_AA(xr1, xr3, xr4,xr2);
    s += S32M2I(xr1); 
    Overflow = 0; 
    if( s < 0)
       Overflow = 1;
    
#else
       
    for (i = 0; i < L_subfr; i++)
    {
        s = L_mac(s, xn[i], y1[i]);
    }
#endif
    //test (); 
    if (Overflow == 0)
    {
        exp_xy = norm_l (s);
        xy = round (L_shl (s, exp_xy));
    }
    else
    {
        s = 1L;                     //move32 (); /* Avoid case of all zeros */
  
#ifdef JZ4740_MXU_OPT

    ptr1 = (unsigned int)(scaled_y1 - 2) & ADD_MASK;
    ref1 = 4 - (unsigned int)scaled_y1 & REF_MASK;
    ptr2 = (unsigned int)(xn - 2) & ADD_MASK;
    ref2 = 4 - (unsigned int)xn & REF_MASK;
    Q16ADD_AA_WW(xr10, xr0,xr0,xr11);  //s = 0;
    S32LDI(xr12, ptr1, 0x04);
    S32LDI(xr13, ptr2, 0x04);
    for( i = 0; i < L_subfr / 2; i++){
       S32LDI(xr1, ptr1, 0x04);
       S32ALN(xr3, xr12, xr1, ref1);
       S32LDI(xr2, ptr2, 0x04);
       S32ALN(xr4, xr13, xr2, ref2);
       Q16SLL(xr12,xr1, xr2,xr13,0);
       D16MAC_AA_WW(xr10, xr3,xr4,xr11);
    }
    D32SLL(xr3, xr10, xr11,xr4, 1);
    D32ADD_AA(xr1, xr3, xr4,xr2);
    s += S32M2I(xr1); 
    Overflow = 0; 
    if( s < 0)
       Overflow = 1;
    
#else
       for (i = 0; i < L_subfr; i++)
        {
            s = L_mac (s, xn[i], scaled_y1[i]);
        }
#endif
        exp_xy = norm_l (s);
        xy = round (L_shl (s, exp_xy));
        exp_xy = sub (exp_xy, 2);
    }

    g_coeff[0] = yy;                 //move16 ();
    g_coeff[1] = sub (15, exp_yy);   //move16 ();
    g_coeff[2] = xy;                 //move16 ();
    g_coeff[3] = sub (15, exp_xy);   //move16 ();
    
    /* If (xy < 4) gain = 0 */

    i = sub (xy, 4);

    //test (); 
    if (i < 0)
        return ((Word16) 0);

    /* compute gain = xy/yy */

    xy = shr (xy, 1);                  /* Be sure xy < yy */
    gain = div_s (xy, yy);

    i = sub (exp_xy, exp_yy);      /* Denormalization of division */        
    gain = shr (gain, i);
    
    /* if(gain >1.2) gain = 1.2 */
    
    //test (); 
    if (sub (gain, 19661) > 0)
    {
        gain = 19661;                   //move16 (); 
    }

    //test ();
    if (sub(mode, MR122) == 0)
    {
       /* clear 2 LSBits */
       gain = gain & 0xfffC;            logic16 ();
    }
    
    return (gain);
}