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(BP)
#define	STEP(k)   (longword)wt[k] * dp[k - lambda]

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

(

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

STEP [2/2]

#define STEP

(

k

)

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

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.

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

References bc, d, dmax, GSM_ABS, gsm_DLB, Nc, S, SASR, and STEP.

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.

{
    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 ];
}

References GSM_ADD(), GSM_MULT_R, gsm_QLB, MIN_WORD, and S.

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.

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

References bc, and STEP.

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.

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

References bc, d, Nc, and S.