mirror of
https://github.com/asterisk/asterisk.git
synced 2025-09-29 18:19:30 +00:00
Remove as much trailing whitespace as possible.
Change-Id: I873c1c6d00f447269bd841494459efccdd2c19c0
This commit is contained in:
@@ -88,7 +88,7 @@ longword gsm_L_sub P2((a,b), longword a, longword b)
|
||||
}
|
||||
else if (b <= 0) return a - b;
|
||||
else {
|
||||
/* a<0, b>0 */
|
||||
/* a<0, b>0 */
|
||||
|
||||
ulongword A = (ulongword)-(a + 1) + b;
|
||||
return A >= MAX_LONGWORD ? MIN_LONGWORD : -(longword)A - 1;
|
||||
@@ -120,7 +120,7 @@ word gsm_norm P1((a), longword a )
|
||||
* variable L_var1 for positive values on the interval
|
||||
*
|
||||
* with minimum of
|
||||
* minimum of 1073741824 (01000000000000000000000000000000) and
|
||||
* minimum of 1073741824 (01000000000000000000000000000000) and
|
||||
* maximum of 2147483647 (01111111111111111111111111111111)
|
||||
*
|
||||
*
|
||||
@@ -141,7 +141,7 @@ word gsm_norm P1((a), longword a )
|
||||
a = ~a;
|
||||
}
|
||||
|
||||
return a & 0xffff0000
|
||||
return a & 0xffff0000
|
||||
? ( a & 0xff000000
|
||||
? -1 + bitoff[ 0xFF & (a >> 24) ]
|
||||
: 7 + bitoff[ 0xFF & (a >> 16) ] )
|
||||
@@ -194,7 +194,7 @@ word gsm_asr P2((a,n), word a, int n)
|
||||
# endif
|
||||
}
|
||||
|
||||
/*
|
||||
/*
|
||||
* (From p. 46, end of section 4.2.5)
|
||||
*
|
||||
* NOTE: The following lines gives [sic] one correct implementation
|
||||
|
@@ -19,8 +19,8 @@
|
||||
#include "gsm.h"
|
||||
#include "proto.h"
|
||||
|
||||
/*
|
||||
* 4.2 FIXED POINT IMPLEMENTATION OF THE RPE-LTP CODER
|
||||
/*
|
||||
* 4.2 FIXED POINT IMPLEMENTATION OF THE RPE-LTP CODER
|
||||
*/
|
||||
|
||||
void Gsm_Coder P8((S,s,LARc,Nc,bc,Mc,xmaxc,xMc),
|
||||
@@ -33,7 +33,7 @@ void Gsm_Coder P8((S,s,LARc,Nc,bc,Mc,xmaxc,xMc),
|
||||
* The RPE-LTD coder works on a frame by frame basis. The length of
|
||||
* the frame is equal to 160 samples. Some computations are done
|
||||
* once per frame to produce at the output of the coder the
|
||||
* LARc[1..8] parameters which are the coded LAR coefficients and
|
||||
* LARc[1..8] parameters which are the coded LAR coefficients and
|
||||
* also to realize the inverse filtering operation for the entire
|
||||
* frame (160 samples of signal d[0..159]). These parts produce at
|
||||
* the output of the coder:
|
||||
|
@@ -18,7 +18,7 @@
|
||||
#include <stdio.h>
|
||||
#include "proto.h"
|
||||
|
||||
void gsm_debug_words P4( (name, from, to, ptr),
|
||||
void gsm_debug_words P4( (name, from, to, ptr),
|
||||
char * name,
|
||||
int from,
|
||||
int to,
|
||||
|
@@ -206,7 +206,7 @@ int gsm_decode P3((s, c, target), gsm s, gsm_byte * c, gsm_signal * target)
|
||||
xmaxc[2] = sr & 0x3f; sr >>= 6;
|
||||
xmc[26] = sr & 0x7; sr >>= 3;
|
||||
xmc[27] = sr & 0x7; sr >>= 3;
|
||||
sr |= (uword)*c++ << 1;
|
||||
sr |= (uword)*c++ << 1;
|
||||
xmc[28] = sr & 0x7; sr >>= 3;
|
||||
xmc[29] = sr & 0x7; sr >>= 3;
|
||||
xmc[30] = sr & 0x7; sr >>= 3;
|
||||
@@ -223,7 +223,7 @@ int gsm_decode P3((s, c, target), gsm s, gsm_byte * c, gsm_signal * target)
|
||||
xmc[38] = sr & 0x7; sr >>= 3;
|
||||
sr = *c++;
|
||||
Nc[3] = sr & 0x7f; sr >>= 7;
|
||||
sr |= (uword)*c++ << 1;
|
||||
sr |= (uword)*c++ << 1;
|
||||
bc[3] = sr & 0x3; sr >>= 2;
|
||||
Mc[3] = sr & 0x3; sr >>= 2;
|
||||
sr |= (uword)*c++ << 5;
|
||||
|
@@ -228,7 +228,7 @@ int gsm_explode P3((s, c, target), gsm s, gsm_byte * c, gsm_signal * target)
|
||||
#define xmc (target + 46 - 26)
|
||||
xmc[26] = sr & 0x7; sr >>= 3;
|
||||
xmc[27] = sr & 0x7; sr >>= 3;
|
||||
sr |= (uword)*c++ << 1;
|
||||
sr |= (uword)*c++ << 1;
|
||||
xmc[28] = sr & 0x7; sr >>= 3;
|
||||
xmc[29] = sr & 0x7; sr >>= 3;
|
||||
xmc[30] = sr & 0x7; sr >>= 3;
|
||||
@@ -245,7 +245,7 @@ int gsm_explode P3((s, c, target), gsm s, gsm_byte * c, gsm_signal * target)
|
||||
xmc[38] = sr & 0x7; sr >>= 3;
|
||||
sr = *c++;
|
||||
Nc[3] = sr & 0x7f; sr >>= 7;
|
||||
sr |= (uword)*c++ << 1;
|
||||
sr |= (uword)*c++ << 1;
|
||||
bc[3] = sr & 0x3; sr >>= 2;
|
||||
Mc[3] = sr & 0x3; sr >>= 2;
|
||||
sr |= (uword)*c++ << 5;
|
||||
@@ -273,7 +273,7 @@ int gsm_explode P3((s, c, target), gsm s, gsm_byte * c, gsm_signal * target)
|
||||
xmc[51] = sr & 0x7; sr >>= 3;
|
||||
}
|
||||
}
|
||||
else
|
||||
else
|
||||
#endif
|
||||
{
|
||||
/* GSM_MAGIC = (*c >> 4) & 0xF; */
|
||||
|
@@ -316,7 +316,7 @@ void gsm_implode P3((s, source, c), gsm s, gsm_signal * source, gsm_byte * c)
|
||||
#define xmc (source + 46 - 26)
|
||||
xmc[26] = sr & 0x7; sr >>= 3;
|
||||
xmc[27] = sr & 0x7; sr >>= 3;
|
||||
sr |= (uword)*c++ << 1;
|
||||
sr |= (uword)*c++ << 1;
|
||||
xmc[28] = sr & 0x7; sr >>= 3;
|
||||
xmc[29] = sr & 0x7; sr >>= 3;
|
||||
xmc[30] = sr & 0x7; sr >>= 3;
|
||||
@@ -333,7 +333,7 @@ void gsm_implode P3((s, source, c), gsm s, gsm_signal * source, gsm_byte * c)
|
||||
xmc[38] = sr & 0x7; sr >>= 3;
|
||||
sr = *c++;
|
||||
Nc[3] = sr & 0x7f; sr >>= 7;
|
||||
sr |= (uword)*c++ << 1;
|
||||
sr |= (uword)*c++ << 1;
|
||||
bc[3] = sr & 0x3; sr >>= 2;
|
||||
Mc[3] = sr & 0x3; sr >>= 2;
|
||||
sr |= (uword)*c++ << 5;
|
||||
@@ -361,7 +361,7 @@ void gsm_implode P3((s, source, c), gsm s, gsm_signal * source, gsm_byte * c)
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif
|
||||
#endif
|
||||
{
|
||||
|
||||
*c++ = ((GSM_MAGIC & 0xF) << 4) /* 1 */
|
||||
|
@@ -56,7 +56,7 @@ int gsm_option P3((r, opt, val), gsm r, int opt, int * val)
|
||||
|
||||
case GSM_OPT_WAV49:
|
||||
|
||||
#ifdef WAV49
|
||||
#ifdef WAV49
|
||||
result = r->wav_fmt;
|
||||
if (val) r->wav_fmt = !!*val;
|
||||
#endif
|
||||
|
@@ -1,7 +1,7 @@
|
||||
/* k6opt.h vector functions optimized for MMX extensions to x86
|
||||
*
|
||||
* Copyright (C) 1999 by Stanley J. Brooks <stabro@megsinet.net>
|
||||
*
|
||||
*
|
||||
* Any use of this software is permitted provided that this notice is not
|
||||
* removed and that neither the authors nor the Technische Universitaet Berlin
|
||||
* are deemed to have made any representations as to the suitability of this
|
||||
@@ -9,7 +9,7 @@
|
||||
* this software. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE;
|
||||
* not even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
||||
* A PARTICULAR PURPOSE.
|
||||
*
|
||||
*
|
||||
* Chicago, 03.12.1999
|
||||
* Stanley J. Brooks
|
||||
*/
|
||||
@@ -22,7 +22,7 @@ extern void Weighting_filter P2((e, x),
|
||||
|
||||
extern longword k6maxcc P3((wt,dp,Nc_out),
|
||||
const word *wt,
|
||||
const word *dp,
|
||||
const word *dp,
|
||||
word * Nc_out /* OUT */
|
||||
)
|
||||
;
|
||||
@@ -34,7 +34,7 @@ extern longword k6maxcc P3((wt,dp,Nc_out),
|
||||
*/
|
||||
extern longword k6maxmin P3((p,n,out),
|
||||
const word *p,
|
||||
int n,
|
||||
int n,
|
||||
word *out /* out[0] is max, out[1] is min */
|
||||
)
|
||||
;
|
||||
@@ -53,7 +53,7 @@ extern longword k6iprod P3((p,q,n),
|
||||
*/
|
||||
extern void k6vsraw P3((p,n,bits),
|
||||
const word *p,
|
||||
int n,
|
||||
int n,
|
||||
int bits
|
||||
)
|
||||
;
|
||||
@@ -65,7 +65,7 @@ extern void k6vsraw P3((p,n,bits),
|
||||
*/
|
||||
extern void k6vsllw P3((p,n,bits),
|
||||
const word *p,
|
||||
int n,
|
||||
int n,
|
||||
int bits
|
||||
)
|
||||
;
|
||||
|
@@ -338,7 +338,7 @@ static void Cut_Calculation_of_the_LTP_parameters P5((st, d,dp,bc_out,Nc_out),
|
||||
else scal = 6 - temp;
|
||||
|
||||
assert(scal >= 0);
|
||||
ltp_cut = (longword)SASR(dmax, scal) * st->ltp_cut / 100;
|
||||
ltp_cut = (longword)SASR(dmax, scal) * st->ltp_cut / 100;
|
||||
|
||||
|
||||
/* Initialization of a working array wt
|
||||
@@ -370,7 +370,7 @@ static void Cut_Calculation_of_the_LTP_parameters P5((st, d,dp,bc_out,Nc_out),
|
||||
register float a = lp[-8], b = lp[-7], c = lp[-6],
|
||||
d = lp[-5], e = lp[-4], f = lp[-3],
|
||||
g = lp[-2], h = lp[-1];
|
||||
register float E;
|
||||
register float E;
|
||||
register float S0 = 0, S1 = 0, S2 = 0, S3 = 0, S4 = 0,
|
||||
S5 = 0, S6 = 0, S7 = 0, S8 = 0;
|
||||
|
||||
@@ -536,7 +536,7 @@ static void Calculation_of_the_LTP_parameters P4((d,dp,bc_out,Nc_out),
|
||||
register float a = lp[-8], b = lp[-7], c = lp[-6],
|
||||
d = lp[-5], e = lp[-4], f = lp[-3],
|
||||
g = lp[-2], h = lp[-1];
|
||||
register float E;
|
||||
register float E;
|
||||
register float S0 = 0, S1 = 0, S2 = 0, S3 = 0, S4 = 0,
|
||||
S5 = 0, S6 = 0, S7 = 0, S8 = 0;
|
||||
|
||||
@@ -750,7 +750,7 @@ static void Fast_Calculation_of_the_LTP_parameters P4((d,dp,bc_out,Nc_out),
|
||||
register float a = lp[-8], b = lp[-7], c = lp[-6],
|
||||
d = lp[-5], e = lp[-4], f = lp[-3],
|
||||
g = lp[-2], h = lp[-1];
|
||||
register float E;
|
||||
register float E;
|
||||
register float S0 = 0, S1 = 0, S2 = 0, S3 = 0, S4 = 0,
|
||||
S5 = 0, S6 = 0, S7 = 0, S8 = 0;
|
||||
|
||||
@@ -867,7 +867,7 @@ static void Long_term_analysis_filtering P6((bc,Nc,dp,d,dpp,e),
|
||||
case 0: STEP( 3277 ); break;
|
||||
case 1: STEP( 11469 ); break;
|
||||
case 2: STEP( 21299 ); break;
|
||||
case 3: STEP( 32767 ); break;
|
||||
case 3: STEP( 32767 ); break;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -888,7 +888,7 @@ void Gsm_Long_Term_Predictor P7((S,d,dp,e,dpp,Nc,bc), /* 4x for 160 samples */
|
||||
assert( dpp); assert( Nc ); assert( bc );
|
||||
|
||||
#if defined(FAST) && defined(USE_FLOAT_MUL)
|
||||
if (S->fast)
|
||||
if (S->fast)
|
||||
#if defined (LTP_CUT)
|
||||
if (S->ltp_cut)
|
||||
Cut_Fast_Calculation_of_the_LTP_parameters(S,
|
||||
@@ -896,7 +896,7 @@ void Gsm_Long_Term_Predictor P7((S,d,dp,e,dpp,Nc,bc), /* 4x for 160 samples */
|
||||
else
|
||||
#endif /* LTP_CUT */
|
||||
Fast_Calculation_of_the_LTP_parameters(d, dp, bc, Nc );
|
||||
else
|
||||
else
|
||||
#endif /* FAST & USE_FLOAT_MUL */
|
||||
#ifdef LTP_CUT
|
||||
if (S->ltp_cut)
|
||||
@@ -936,7 +936,7 @@ void Gsm_Long_Term_Synthesis_Filtering P5((S,Ncr,bcr,erp,drp),
|
||||
*/
|
||||
brp = gsm_QLB[ bcr ];
|
||||
|
||||
/* Computation of the reconstructed short term residual
|
||||
/* Computation of the reconstructed short term residual
|
||||
* signal drp[0..39]
|
||||
*/
|
||||
assert(brp != MIN_WORD);
|
||||
|
@@ -84,7 +84,7 @@ static void Autocorrelation P2((s, L_ACF),
|
||||
float_s[k] = (float) \
|
||||
(s[k] = GSM_MULT_R(s[k], 16384 >> (n-1)));\
|
||||
break;
|
||||
# else
|
||||
# else
|
||||
# define SCALE(n) \
|
||||
case n: for (k = 0; k <= 159; k++) \
|
||||
s[k] = (word)GSM_MULT_R( s[k], 16384 >> (n-1) );\
|
||||
@@ -153,7 +153,7 @@ static void Autocorrelation P2((s, L_ACF),
|
||||
STEP(5); STEP(6); STEP(7); STEP(8);
|
||||
}
|
||||
|
||||
for (k = 9; k--; L_ACF[k] <<= 1) ;
|
||||
for (k = 9; k--; L_ACF[k] <<= 1) ;
|
||||
|
||||
}
|
||||
|
||||
@@ -168,7 +168,7 @@ static void Autocorrelation P2((s, L_ACF),
|
||||
/* Rescaling of the array s[0..159]
|
||||
*/
|
||||
if (scalauto > 0) {
|
||||
assert(scalauto <= 4);
|
||||
assert(scalauto <= 4);
|
||||
#ifndef K6OPT
|
||||
for (k = 160; k--; *s++ <<= scalauto) ;
|
||||
# else /* K6OPT */
|
||||
@@ -256,7 +256,7 @@ static void Reflection_coefficients P2( (L_ACF, r),
|
||||
assert(*r >= 0);
|
||||
if (P[1] > 0) *r = -*r; /* r[n] = sub(0, r[n]) */
|
||||
assert (*r != MIN_WORD);
|
||||
if (n == 8) return;
|
||||
if (n == 8) return;
|
||||
|
||||
/* Schur recursion
|
||||
*/
|
||||
@@ -325,7 +325,7 @@ static void Quantization_and_coding P1((LAR),
|
||||
|
||||
/* This procedure needs four tables; the following equations
|
||||
* give the optimum scaling for the constants:
|
||||
*
|
||||
*
|
||||
* A[0..7] = integer( real_A[0..7] * 1024 )
|
||||
* B[0..7] = integer( real_B[0..7] * 512 )
|
||||
* MAC[0..7] = maximum of the LARc[0..7]
|
||||
|
@@ -15,7 +15,7 @@
|
||||
#include "proto.h"
|
||||
|
||||
/* 4.2.0 .. 4.2.3 PREPROCESSING SECTION
|
||||
*
|
||||
*
|
||||
* After A-law to linear conversion (or directly from the
|
||||
* Ato D converter) the following scaling is assumed for
|
||||
* input to the RPE-LTP algorithm:
|
||||
@@ -26,7 +26,7 @@
|
||||
* Where S is the sign bit, v a valid bit, and * a "don't care" bit.
|
||||
* The original signal is called sop[..]
|
||||
*
|
||||
* out: 0.1................... 12
|
||||
* out: 0.1................... 12
|
||||
* S.S.v.v.v.v.v.v.v.v.v.v.v.v.0.0
|
||||
*/
|
||||
|
||||
@@ -59,7 +59,7 @@ void Gsm_Preprocess P3((S, s, so),
|
||||
|
||||
|
||||
/* 4.2.2 Offset compensation
|
||||
*
|
||||
*
|
||||
* This part implements a high-pass filter and requires extended
|
||||
* arithmetic precision for the recursive part of this filter.
|
||||
* The input of this procedure is the array so[0...159] and the
|
||||
@@ -82,15 +82,15 @@ void Gsm_Preprocess P3((S, s, so),
|
||||
*/
|
||||
{
|
||||
word msp;
|
||||
#ifndef __GNUC__
|
||||
#ifndef __GNUC__
|
||||
word lsp;
|
||||
#endif
|
||||
longword L_s2;
|
||||
longword L_temp;
|
||||
|
||||
|
||||
L_s2 = s1;
|
||||
L_s2 <<= 15;
|
||||
#ifndef __GNUC__
|
||||
#ifndef __GNUC__
|
||||
msp = (word)SASR( L_z2, 15 );
|
||||
lsp = (word)(L_z2 & 0x7fff); /* gsm_L_sub(L_z2,(msp<<15)); */
|
||||
|
||||
|
@@ -29,7 +29,7 @@ static void Weighting_filter P2((e, x),
|
||||
* The coefficients of the weighting filter are stored in a table
|
||||
* (see table 4.4). The following scaling is used:
|
||||
*
|
||||
* H[0..10] = integer( real_H[ 0..10] * 8192 );
|
||||
* H[0..10] = integer( real_H[ 0..10] * 8192 );
|
||||
*/
|
||||
{
|
||||
/* word wt[ 50 ]; */
|
||||
@@ -50,7 +50,7 @@ static void Weighting_filter P2((e, x),
|
||||
e -= 5;
|
||||
|
||||
/* Compute the signal x[0..39]
|
||||
*/
|
||||
*/
|
||||
for (k = 0; k <= 39; k++) {
|
||||
|
||||
L_result = 8192 >> 1;
|
||||
@@ -65,7 +65,7 @@ static void Weighting_filter P2((e, x),
|
||||
#define STEP( i, H ) (e[ k + i ] * (longword)H)
|
||||
|
||||
/* Every one of these multiplications is done twice --
|
||||
* but I don't see an elegant way to optimize this.
|
||||
* but I don't see an elegant way to optimize this.
|
||||
* Do you?
|
||||
*/
|
||||
|
||||
@@ -83,16 +83,16 @@ static void Weighting_filter P2((e, x),
|
||||
L_result += STEP( 10, -134 ) ;
|
||||
#else
|
||||
L_result +=
|
||||
STEP( 0, -134 )
|
||||
+ STEP( 1, -374 )
|
||||
STEP( 0, -134 )
|
||||
+ STEP( 1, -374 )
|
||||
/* + STEP( 2, 0 ) */
|
||||
+ STEP( 3, 2054 )
|
||||
+ STEP( 4, 5741 )
|
||||
+ STEP( 5, 8192 )
|
||||
+ STEP( 6, 5741 )
|
||||
+ STEP( 7, 2054 )
|
||||
+ STEP( 3, 2054 )
|
||||
+ STEP( 4, 5741 )
|
||||
+ STEP( 5, 8192 )
|
||||
+ STEP( 6, 5741 )
|
||||
+ STEP( 7, 2054 )
|
||||
/* + STEP( 8, 0 ) */
|
||||
+ STEP( 9, -374 )
|
||||
+ STEP( 9, -374 )
|
||||
+ STEP(10, -134 )
|
||||
;
|
||||
#endif
|
||||
@@ -117,7 +117,7 @@ static void Weighting_filter P2((e, x),
|
||||
/* 4.2.14 */
|
||||
|
||||
static void RPE_grid_selection P3((x,xM,Mc_out),
|
||||
word * x, /* [0..39] IN */
|
||||
word * x, /* [0..39] IN */
|
||||
word * xM, /* [0..12] OUT */
|
||||
word * Mc_out /* OUT */
|
||||
)
|
||||
@@ -150,7 +150,7 @@ static void RPE_grid_selection P3((x,xM,Mc_out),
|
||||
* L_temp = GSM_L_MULT( temp1, temp1 );
|
||||
* L_result = GSM_L_ADD( L_temp, L_result );
|
||||
* }
|
||||
*
|
||||
*
|
||||
* if (L_result > EM) {
|
||||
* Mc = m;
|
||||
* EM = L_result;
|
||||
@@ -313,7 +313,7 @@ static void APCM_quantization P5((xM,xMc,mant_out,exp_out,xmaxc_out),
|
||||
* can be calculated by using the exponent and the mantissa part of
|
||||
* xmaxc (logarithmic table).
|
||||
* So, this method avoids any division and uses only a scaling
|
||||
* of the RPE samples by a function of the exponent. A direct
|
||||
* of the RPE samples by a function of the exponent. A direct
|
||||
* multiplication by the inverse of the mantissa (NRFAC[0..7]
|
||||
* found in table 4.5) gives the 3 bit coded version xMc[0..12]
|
||||
* of the RPE samples.
|
||||
@@ -324,7 +324,7 @@ static void APCM_quantization P5((xM,xMc,mant_out,exp_out,xmaxc_out),
|
||||
*/
|
||||
|
||||
assert( exp <= 4096 && exp >= -4096);
|
||||
assert( mant >= 0 && mant <= 7 );
|
||||
assert( mant >= 0 && mant <= 7 );
|
||||
|
||||
temp1 = 6 - exp; /* normalization by the exponent */
|
||||
temp2 = gsm_NRFAC[ mant ]; /* inverse mantissa */
|
||||
@@ -354,7 +354,7 @@ static void APCM_inverse_quantization P4((xMc,mant,exp,xMp),
|
||||
word mant,
|
||||
word exp,
|
||||
register word * xMp) /* [0..12] OUT */
|
||||
/*
|
||||
/*
|
||||
* This part is for decoding the RPE sequence of coded xMc[0..12]
|
||||
* samples to obtain the xMp[0..12] array. Table 4.6 is used to get
|
||||
* the mantissa of xmaxc (FAC[0..7]).
|
||||
@@ -363,7 +363,7 @@ static void APCM_inverse_quantization P4((xMc,mant,exp,xMp),
|
||||
int i;
|
||||
word temp, temp1, temp2, temp3;
|
||||
|
||||
assert( mant >= 0 && mant <= 7 );
|
||||
assert( mant >= 0 && mant <= 7 );
|
||||
|
||||
temp1 = gsm_FAC[ mant ]; /* see 4.2-15 for mant */
|
||||
temp2 = gsm_sub( 6, exp ); /* see 4.2-15 for exp */
|
||||
@@ -440,7 +440,7 @@ void Gsm_Update_of_reconstructed_short_time_residual_signal P3((dpp, ep, dp),
|
||||
{
|
||||
int k;
|
||||
|
||||
for (k = 0; k <= 79; k++)
|
||||
for (k = 0; k <= 79; k++)
|
||||
dp[ -120 + k ] = dp[ -80 + k ];
|
||||
|
||||
for (k = 0; k <= 39; k++)
|
||||
|
@@ -77,7 +77,7 @@ static void Decoding_of_the_coded_Log_Area_Ratios P2((LARc,LARpp),
|
||||
}
|
||||
|
||||
/* 4.2.9 */
|
||||
/* Computation of the quantized reflection coefficients
|
||||
/* Computation of the quantized reflection coefficients
|
||||
*/
|
||||
|
||||
/* 4.2.9.1 Interpolation of the LARpp[1..8] to get the LARp[1..8]
|
||||
@@ -401,7 +401,7 @@ void Gsm_Short_Term_Analysis_Filter P3((S,LARc,s),
|
||||
Coefficients_40_159( LARpp_j, LARp);
|
||||
LARp_to_rp( LARp );
|
||||
FILTER( S->u, LARp, 120, s + 40);
|
||||
|
||||
|
||||
}
|
||||
|
||||
void Gsm_Short_Term_Synthesis_Filter P4((S, LARcr, wt, s),
|
||||
|
@@ -51,7 +51,7 @@ word gsm_QLB[4] = { 3277, 11469, 21299, 32767 };
|
||||
word gsm_H[11] = {-134, -374, 0, 2054, 5741, 8192, 5741, 2054, 0, -374, -134 };
|
||||
|
||||
|
||||
/* Table 4.5 Normalized inverse mantissa used to compute xM/xmax
|
||||
/* Table 4.5 Normalized inverse mantissa used to compute xM/xmax
|
||||
*/
|
||||
/* i 0 1 2 3 4 5 6 7 */
|
||||
word gsm_NRFAC[8] = { 29128, 26215, 23832, 21846, 20165, 18725, 17476, 16384 };
|
||||
|
Reference in New Issue
Block a user