s10_8pf.c

来自「君正早期ucos系统(只有早期的才不没有打包成库),MPLAYER,文件系统,图」· C语言 代码 · 共 587 行 · 第 1/2 页

/*
********************************************************************************
*
*      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             : s10_8pf.c
*      Purpose          : Searches a 35/31 bit algebraic codebook containing 
*                       : 10/8 pulses in a frame of 40 samples.
*
********************************************************************************
*/
/*
********************************************************************************
*                         MODULE INCLUDE FILE AND VERSION ID
********************************************************************************
*/
#include "s10_8pf.h"
const char s10_8pf_id[] = "@(#)$Id $" s10_8pf_h;
/*
********************************************************************************
*                         INCLUDE FILES
********************************************************************************
*/
#include "typedef.h"
#include "basic_op.h"
#include "count.h"
#include "cnst.h"
//add for jzmedia accerative instruction sets
#ifdef JZ4740_MXU_OPT
#include "jzmedia.h"
#endif

/*
********************************************************************************
*                         LOCAL VARIABLES AND TABLES
********************************************************************************
*/

/*************************************************************************
 *
 *  FUNCTION  search_10and8i40()
 *
 *  PURPOSE: Search the best codevector; determine positions of the 10/8 
 *           pulses in the 40-sample frame.
 *
 *   search_10and8i40 (10,5,5,dn, rr, ipos, pos_max, codvec);   for GSMEFR
 *   search_10and8i40 (8, 4,4,dn, rr, ipos, pos_max, codvec);   for 10.2
 *
 *************************************************************************/
#ifdef JZ4740_MXU_OPT
#define _1_2    16384             //(Word16)(32768L/2)
#define _1_4     8192             //(Word16)(32768L/4)
#define _1_8     4096             //(Word16)(32768L/8)
#define _1_16    2048             //(Word16)(32768L/16)
#define _1_32    1024             //(Word16)(32768L/32)
#define _1_64     512             //(Word16)(32768L/64)
#define _1_128    256             //(Word16)(32768L/128)
#else
#define _1_2    (Word16)(32768L/2)
#define _1_4    (Word16)(32768L/4)
#define _1_8    (Word16)(32768L/8)
#define _1_16   (Word16)(32768L/16)
#define _1_32   (Word16)(32768L/32)
#define _1_64   (Word16)(32768L/64)
#define _1_128  (Word16)(32768L/128)
#endif
void search_10and8i40 (
    Word16 nbPulse,      /* i : nbpulses to find                       */
    Word16 step,         /* i :  stepsize                              */
    Word16 nbTracks,     /* i :  nbTracks                              */
    Word16 dn[],         /* i : correlation between target and h[]     */
#ifdef JZ4740_MXU_OPT
    Word16 rr[], /* i : matrix of autocorrelation              */
#else
    Word16 rr[][L_CODE], /* i : matrix of autocorrelation              */
#endif
    Word16 ipos[],       /* i : starting position for each pulse       */
    Word16 pos_max[],    /* i : position of maximum of dn[]            */
    Word16 codvec[]      /* o : algebraic codebook vector              */
)
{
   Word16 i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
   Word16 i, j, k, pos, ia, ib;
   Word16 psk, ps, ps0, ps1, ps2, sq, sq2;
   Word16 alpk, alp, alp_16;
   Word16 rrv[L_CODE];
   Word32 s, alp0, alp1, alp2;
   Word16 gsmefrFlag;
   Word32 i0Len, i1Len, i2Len, i3Len, i4Len, i5Len, i6Len, i7Len, i8Len;

   //test(); 
   if (sub(nbPulse, 10) == 0)
   {
      gsmefrFlag=1;                             //move16 ();
   }
   else
   {
      gsmefrFlag=0;                             //move16 (); 
   }

   /* fix i0 on maximum of correlation position */
   i0 = pos_max[ipos[0]];                       //move16 (); 
   i0Len = i0 * L_CODE;
   
   /*------------------------------------------------------------------*
    * i1 loop:                                                         *
    *------------------------------------------------------------------*/
   
   /* Default value */
   psk = -1;                                    //move16 (); 
   alpk = 1;                                    //move16 (); 
   for (i = 0; i < nbPulse; i++)
   {
      codvec[i] = i;                            //move16 ();
   }

   for (i = 1; i < nbTracks; i++)
   {
      i1 = pos_max[ipos[1]];                    //move16 (); 
      i1Len = i1 * L_CODE;
      ps0 = add (dn[i0], dn[i1]);
#ifdef JZ4740_MXU_OPT
      alp0 = L_mult (rr[i0Len +i0], _1_16);
      alp0 = L_mac (alp0, rr[i1Len + i1], _1_16);
      alp0 = L_mac (alp0, rr[i0Len + i1], _1_8);
//      printf("alp0 = %d.\n", alp0);
#else
      alp0 = L_mult (rr[i0][i0], _1_16);
      alp0 = L_mac (alp0, rr[i1][i1], _1_16);
      alp0 = L_mac (alp0, rr[i0][i1], _1_8);
//      printf("alp0 = %d.\n", alp0);
#endif      
      /*----------------------------------------------------------------*
       * i2 and i3 loop:                                                *
       *----------------------------------------------------------------*/
      
      /* initialize 4 indices for next loop. */
      //move16 (); /* initialize "rr[i3][i3]" pointer */
      //move16 (); /* initialize "rr[i0][i3]" pointer */
      //move16 (); /* initialize "rr[i1][i3]" pointer */
      //move16 (); /* initialize "rrv[i3]" pointer    */
      
      for (i3 = ipos[3]; i3 < L_CODE; i3 += step)
      {
#ifndef JZ4740_MXU_OPT 
         s = L_mult (rr[i3][i3], _1_8);       /* index incr= step+L_CODE */
         s = L_mac (s, rr[i0][i3], _1_4);     /* index increment = step  */
         s = L_mac (s, rr[i1][i3], _1_4);     /* index increment = step  */
//         printf("s = %d, ", s);
#else
         s = L_mult (rr[i3 * L_CODE + i3], _1_8);       /* index incr= step+L_CODE */
         s = L_mac (s, rr[i0Len + i3], _1_4);     /* index increment = step  */
         s = L_mac (s, rr[i1Len + i3], _1_4);     /* index increment = step  */
//         printf("s = %d\n ", s);
#endif
         rrv[i3] = round (s);                 //move16 (); 
      }
      /* Default value */
      sq = -1;                                 //move16 (); 
      alp = 1;                                 //move16 (); 
      ps = 0;                                  //move16 ();
      ia = ipos[2];                            //move16 ();
      ib = ipos[3];                            //move16 ();
      
      /* initialize 4 indices for i2 loop. */
      //move16 (); /* initialize "dn[i2]" pointer     */
      //move16 (); /* initialize "rr[i2][i2]" pointer */
      //move16 (); /* initialize "rr[i0][i2]" pointer */
      //move16 (); /* initialize "rr[i1][i2]" pointer */
        
      for (i2 = ipos[2]; i2 < L_CODE; i2 += step)
      {
         /* index increment = step  */            
         ps1 = add (ps0, dn[i2]);    
#ifndef JZ4740_MXU_OPT          
         /* index incr= step+L_CODE */
         alp1 = L_mac (alp0, rr[i2][i2], _1_16);
            /* index increment = step  */
         alp1 = L_mac (alp1, rr[i0][i2], _1_8);
         /* index increment = step  */
         alp1 = L_mac (alp1, rr[i1][i2], _1_8);
         //printf("alp1 = %d, ", alp1); 
#else
         /* index incr= step+L_CODE */
         alp1 = L_mac (alp0, rr[i2 * L_CODE + i2], _1_16);
            /* index increment = step  */
         alp1 = L_mac (alp1, rr[i0Len + i2], _1_8);
         /* index increment = step  */
         alp1 = L_mac (alp1, rr[i1Len + i2], _1_8);
         
//         printf("alp1 = %d\n ", alp1); 
#endif
         /* initialize 3 indices for i3 inner loop */
         //move16 (); /* initialize "dn[i3]" pointer     */
         //move16 (); /* initialize "rrv[i3]" pointer    */
         //move16 (); /* initialize "rr[i2][i3]" pointer */
         i2Len = i2 * L_CODE;
         for (i3 = ipos[3]; i3 < L_CODE; i3 += step)
         {
            /* index increment = step */                
            ps2 = add (ps1, dn[i3]);    
                
            /* index increment = step */
            alp2 = L_mac (alp1, rrv[i3], _1_2);
#ifndef JZ4740_MXU_OPT
            /* index increment = step */
            alp2 = L_mac (alp2, rr[i2][i3], _1_8);
#else
            alp2 = L_mac (alp2, rr[i2Len + i3], _1_8);

#endif            
            sq2 = mult (ps2, ps2);
            
            alp_16 = round (alp2);
            
            s = L_msu (L_mult (alp, sq2), sq, alp_16);
                
            //test (); 
            if (s > 0)
            {
               sq = sq2;                    //move16 (); 
               ps = ps2;                    //move16 (); 
               alp = alp_16;                //move16 (); 
               ia = i2;                     //move16 (); 
               ib = i3;                     //move16 (); 
            }
         }
      }
      i2 = ia;                                 //move16 (); 
      i3 = ib;                                 //move16 (); 
      i2Len = i2 * L_CODE;
      i3Len = i3 * L_CODE;
      
        /*----------------------------------------------------------------*
         * i4 and i5 loop:                                                *
         *----------------------------------------------------------------*/
        
        ps0 = ps;                                //move16 (); 
        alp0 = L_mult (alp, _1_2);
        
        /* initialize 6 indices for next loop (see i2-i3 loop) */
#if 0
        move16 (); move16 (); move16 (); move16 (); move16 (); move16 (); 
#endif        
        for (i5 = ipos[5]; i5 < L_CODE; i5 += step)
        {
#ifndef JZ4740_MXU_OPT 
            s = L_mult (rr[i5][i5], _1_8);
            s = L_mac (s, rr[i0][i5], _1_4);
            s = L_mac (s, rr[i1][i5], _1_4);
            s = L_mac (s, rr[i2][i5], _1_4);
            s = L_mac (s, rr[i3][i5], _1_4);
//            printf("s = %d, ", s);
#else
            s = L_mult (rr[i5 * L_CODE + i5], _1_8);
            s = L_mac (s, rr[i0Len + i5], _1_4);
            s = L_mac (s, rr[i1Len + i5], _1_4);
            s = L_mac (s, rr[i2Len + i5], _1_4);
            s = L_mac (s, rr[i3Len + i5], _1_4);
//            printf("s = %d\n ", s);
#endif
            rrv[i5] = round (s);                 //move16 (); 
        }
        /* Default value */
        sq = -1;                                 //move16 (); 
        alp = 1;                                 //move16 (); 
        ps = 0;                                  //move16 ();
        ia = ipos[4];                            //move16 ();
        ib = ipos[5];                            //move16 ();
        
        /* initialize 6 indices for i4 loop (see i2-i3 loop) */
#if 0
        move16 (); move16 (); move16 (); move16 (); move16 (); move16 (); 
#endif        
        for (i4 = ipos[4]; i4 < L_CODE; i4 += step)
        {
            ps1 = add (ps0, dn[i4]);
#ifndef JZ4740_MXU_OPT             
            alp1 = L_mac (alp0, rr[i4][i4], _1_32);
            alp1 = L_mac (alp1, rr[i0][i4], _1_16);
            alp1 = L_mac (alp1, rr[i1][i4], _1_16);
            alp1 = L_mac (alp1, rr[i2][i4], _1_16);
            alp1 = L_mac (alp1, rr[i3][i4], _1_16);
//            printf(" alp1 = %d, ", alp1);
#else
          
            alp1 = L_mac (alp0, rr[i4 * L_CODE + i4], _1_32);
            alp1 = L_mac (alp1, rr[i0Len + i4], _1_16);
            alp1 = L_mac (alp1, rr[i1Len + i4], _1_16);
            alp1 = L_mac (alp1, rr[i2Len + i4], _1_16);