long_term.c File Reference

#include <stdio.h>
#include <assert.h>
#include "private.h"
#include "gsm.h"
#include "proto.h"

Include dependency graph for long_term.c:

Go to the source code of this file.

Macros
#define	STEP(k)   (longword)wt[k] * dp[k - lambda]
#define	STEP(BP)

Functions
static void Calculation_of_the_LTP_parameters	P4 ((d, dp, bc_out, Nc_out), register word *d, register word *dp, word *bc_out, word *Nc_out)
void Gsm_Long_Term_Synthesis_Filtering	P5 ((S, Ncr, bcr, erp, drp), struct gsm_state *S, word Ncr, word bcr, register word *erp, register word *drp)
static void Long_term_analysis_filtering	P6 ((bc, Nc, dp, d, dpp, e), word bc, word Nc, register word *dp, register word *d, register word *dpp, register word *e)
void Gsm_Long_Term_Predictor	P7 ((S, d, dp, e, dpp, Nc, bc), struct gsm_state *S, word *d, word *dp, word *e, word *dpp, word *Nc, word *bc)

Macro Definition Documentation

STEP [1/2]

#define STEP

(

k

)

(longword)wt[k] * dp[k - lambda]

Referenced by P4(), and P6().

STEP [2/2]

#define STEP

(

BP

)

Value:

for (k = 0; k <= 39; k++) {         \
      dpp[k]  = (word)GSM_MULT_R( BP, dp[k - Nc]); \
      e[k]  = GSM_SUB( d[k], dpp[k] ); \
   }

Function Documentation

P4()

static void Calculation_of_the_LTP_parameters P4 ( (d, dp, bc_out, Nc_out)  , register word *  d, register word *  dp, word *  bc_out, word *  Nc_out  )

static

Definition at line 158 of file long_term.c.

References a, b, bc, c, dmax, GSM_ABS, gsm_DLB, gsm_state::ltp_cut, Nc, P5(), S, SASR, and STEP.

{
   register int   k;
#ifndef K6OPT
   register int lambda;
#endif
   word     Nc, bc;
   word     wt[40];

   longword L_max, L_power;
   word     R, S, dmax, scal;
   register word  temp;

   /*  Search of the optimum scaling of d[0..39].
    */
   dmax = 0;

   for (k = 0; k <= 39; k++) {
      temp = d[k];
      temp = GSM_ABS( temp );
      if (temp > dmax) dmax = temp;
   }

   temp = 0;
   if (dmax == 0) scal = 0;
   else {
      assert(dmax > 0);
      temp = gsm_norm( (longword)dmax << 16 );
   }

   if (temp > 6) scal = 0;
   else scal = 6 - temp;

   assert(scal >= 0);

   /*  Initialization of a working array wt
    */

   for (k = 0; k <= 39; k++) wt[k] = SASR( d[k], scal );

   /* Search for the maximum cross-correlation and coding of the LTP lag
    */
# ifdef K6OPT
   L_max = k6maxcc(wt,dp,&Nc);
#  else
   L_max = 0;
   Nc    = 40; /* index for the maximum cross-correlation */

   for (lambda = 40; lambda <= 120; lambda++) {

# undef STEP
#     define STEP(k)    (longword)wt[k] * dp[k - lambda]

      register longword L_result;

      L_result  = STEP(0)  ; L_result += STEP(1) ;
      L_result += STEP(2)  ; L_result += STEP(3) ;
      L_result += STEP(4)  ; L_result += STEP(5)  ;
      L_result += STEP(6)  ; L_result += STEP(7)  ;
      L_result += STEP(8)  ; L_result += STEP(9)  ;
      L_result += STEP(10) ; L_result += STEP(11) ;
      L_result += STEP(12) ; L_result += STEP(13) ;
      L_result += STEP(14) ; L_result += STEP(15) ;
      L_result += STEP(16) ; L_result += STEP(17) ;
      L_result += STEP(18) ; L_result += STEP(19) ;
      L_result += STEP(20) ; L_result += STEP(21) ;
      L_result += STEP(22) ; L_result += STEP(23) ;
      L_result += STEP(24) ; L_result += STEP(25) ;
      L_result += STEP(26) ; L_result += STEP(27) ;
      L_result += STEP(28) ; L_result += STEP(29) ;
      L_result += STEP(30) ; L_result += STEP(31) ;
      L_result += STEP(32) ; L_result += STEP(33) ;
      L_result += STEP(34) ; L_result += STEP(35) ;
      L_result += STEP(36) ; L_result += STEP(37) ;
      L_result += STEP(38) ; L_result += STEP(39) ;

      if (L_result > L_max) {

         Nc    = lambda;
         L_max = L_result;
      }
   }
#  endif
   *Nc_out = Nc;

   L_max <<= 1;

   /*  Rescaling of L_max
    */
   assert(scal <= 100 && scal >=  -100);
   L_max = L_max >> (6 - scal);  /* sub(6, scal) */

   assert( Nc <= 120 && Nc >= 40);

   /*   Compute the power of the reconstructed short term residual
    *   signal dp[..]
    */
   L_power = 0;
   for (k = 0; k <= 39; k++) {

      register longword L_temp;

      L_temp   = SASR( dp[k - Nc], 3 );
      L_power += L_temp * L_temp;
   }
   L_power <<= 1; /* from L_MULT */

   /*  Normalization of L_max and L_power
    */

   if (L_max <= 0)  {
      *bc_out = 0;
      return;
   }
   if (L_max >= L_power) {
      *bc_out = 3;
      return;
   }

   temp = gsm_norm( L_power );

   R = (word)SASR( L_max   << temp, 16 );
   S = (word)SASR( L_power << temp, 16 );

   /*  Coding of the LTP gain
    */

   /*  Table 4.3a must be used to obtain the level DLB[i] for the
    *  quantization of the LTP gain b to get the coded version bc.
    */
   for (bc = 0; bc <= 2; bc++) if (R <= gsm_mult(S, gsm_DLB[bc])) break;
   *bc_out = bc;
}

P5()

void Gsm_Long_Term_Synthesis_Filtering P5	(	(S, Ncr, bcr, erp, drp)	,
		struct gsm_state *	S,
		word	Ncr,
		word	bcr,
		register word *	erp,
		register word *	drp
	)

Definition at line 912 of file long_term.c.

References GSM_ADD(), GSM_MULT_R, gsm_QLB, MIN_WORD, and gsm_state::nrp.

Referenced by P4().

{
   register int      k;
   word        brp, drpp, Nr;

   /*  Check the limits of Nr.
    */
   Nr = Ncr < 40 || Ncr > 120 ? S->nrp : Ncr;
   S->nrp = Nr;
   assert(Nr >= 40 && Nr <= 120);

   /*  Decoding of the LTP gain bcr
    */
   brp = gsm_QLB[ bcr ];

   /*  Computation of the reconstructed short term residual
    *  signal drp[0..39]
    */
   assert(brp != MIN_WORD);

   for (k = 0; k <= 39; k++) {
      drpp   = (word)GSM_MULT_R( brp, drp[ k - Nr ] );
      drp[k] = GSM_ADD( erp[k], drpp );
   }

   /*
    *  Update of the reconstructed short term residual signal
    *  drp[ -1..-120 ]
    */

   for (k = 0; k <= 119; k++) drp[ -120 + k ] = drp[ -80 + k ];
}

P6()

static void Long_term_analysis_filtering P6 ( (bc, Nc, dp, d, dpp, e)  , word  bc, word  Nc, register word *  dp, register word *  d, register word *  dpp, register word *  e  )

static

Definition at line 842 of file long_term.c.

References STEP.

{
   register int      k;

#  undef STEP
#  define STEP(BP)               \
   for (k = 0; k <= 39; k++) {         \
      dpp[k]  = (word)GSM_MULT_R( BP, dp[k - Nc]); \
      e[k]  = GSM_SUB( d[k], dpp[k] ); \
   }

   switch (bc) {
   case 0:  STEP(  3277 ); break;
   case 1:  STEP( 11469 ); break;
   case 2: STEP( 21299 ); break;
   case 3: STEP( 32767 ); break;
   }
}

P7()

void Gsm_Long_Term_Predictor P7	(	(S, d, dp, e, dpp, Nc, bc)	,
		struct gsm_state *	S,
		word *	d,
		word *	dp,
		word *	e,
		word *	dpp,
		word *	Nc,
		word *	bc
	)

Definition at line 874 of file long_term.c.

References gsm_state::fast, and gsm_state::ltp_cut.

{
   assert( d  ); assert( dp ); assert( e  );
   assert( dpp); assert( Nc ); assert( bc );

#if defined(FAST) && defined(USE_FLOAT_MUL)
   if (S->fast)
#if   defined (LTP_CUT)
      if (S->ltp_cut)
         Cut_Fast_Calculation_of_the_LTP_parameters(S,
            d, dp, bc, Nc);
      else
#endif /* LTP_CUT */
         Fast_Calculation_of_the_LTP_parameters(d, dp, bc, Nc );
   else
#endif /* FAST & USE_FLOAT_MUL */
#ifdef LTP_CUT
      if (S->ltp_cut)
         Cut_Calculation_of_the_LTP_parameters(S, d, dp, bc, Nc);
      else
#endif
         Calculation_of_the_LTP_parameters(d, dp, bc, Nc);

   Long_term_analysis_filtering( *bc, *Nc, dp, d, dpp, e );
}