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 );
}