1 /*---------------------------------------------------------------------------*\ 2 Original copyright 3 FILE........: lsp.c 4 AUTHOR......: David Rowe 5 DATE CREATED: 24/2/93 6 7 Heavily modified by Jean-Marc Valin (c) 2002-2006 (fixed-point, 8 optimizations, additional functions, ...) 9 10 This file contains functions for converting Linear Prediction 11 Coefficients (LPC) to Line Spectral Pair (LSP) and back. Note that the 12 LSP coefficients are not in radians format but in the x domain of the 13 unit circle. 14 15 Speex License: 16 17 Redistribution and use in source and binary forms, with or without 18 modification, are permitted provided that the following conditions 19 are met: 20 21 - Redistributions of source code must retain the above copyright 22 notice, this list of conditions and the following disclaimer. 23 24 - Redistributions in binary form must reproduce the above copyright 25 notice, this list of conditions and the following disclaimer in the 26 documentation and/or other materials provided with the distribution. 27 28 - Neither the name of the Xiph.org Foundation nor the names of its 29 contributors may be used to endorse or promote products derived from 30 this software without specific prior written permission. 31 32 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 33 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 34 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 35 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR 36 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 37 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 38 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 39 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 40 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 41 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 42 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 43 */ 44 45 /*---------------------------------------------------------------------------*\ 46 47 Introduction to Line Spectrum Pairs (LSPs) 48 ------------------------------------------ 49 50 LSPs are used to encode the LPC filter coefficients {ak} for 51 transmission over the channel. LSPs have several properties (like 52 less sensitivity to quantisation noise) that make them superior to 53 direct quantisation of {ak}. 54 55 A(z) is a polynomial of order lpcrdr with {ak} as the coefficients. 56 57 A(z) is transformed to P(z) and Q(z) (using a substitution and some 58 algebra), to obtain something like: 59 60 A(z) = 0.5[P(z)(z+z^-1) + Q(z)(z-z^-1)] (1) 61 62 As you can imagine A(z) has complex zeros all over the z-plane. P(z) 63 and Q(z) have the very neat property of only having zeros _on_ the 64 unit circle. So to find them we take a test point z=exp(jw) and 65 evaluate P (exp(jw)) and Q(exp(jw)) using a grid of points between 0 66 and pi. 67 68 The zeros (roots) of P(z) also happen to alternate, which is why we 69 swap coefficients as we find roots. So the process of finding the 70 LSP frequencies is basically finding the roots of 5th order 71 polynomials. 72 73 The root so P(z) and Q(z) occur in symmetrical pairs at +/-w, hence 74 the name Line Spectrum Pairs (LSPs). 75 76 To convert back to ak we just evaluate (1), "clocking" an impulse 77 thru it lpcrdr times gives us the impulse response of A(z) which is 78 {ak}. 79 80 \*---------------------------------------------------------------------------*/ 81 82 #ifdef HAVE_CONFIG_H 83 #include "config.h" 84 #endif 85 86 #include <math.h> 87 #include "lsp.h" 88 #include "stack_alloc.h" 89 #include "math_approx.h" 90 91 #ifndef M_PI 92 #define M_PI 3.14159265358979323846 /* pi */ 93 #endif 94 95 #ifndef NULL 96 #define NULL 0 97 #endif 98 99 #ifdef FIXED_POINT 100 101 #define FREQ_SCALE 16384 102 103 /*#define ANGLE2X(a) (32768*cos(((a)/8192.)))*/ 104 #define ANGLE2X(a) (SHL16(spx_cos(a),2)) 105 106 /*#define X2ANGLE(x) (acos(.00006103515625*(x))*LSP_SCALING)*/ 107 #define X2ANGLE(x) (spx_acos(x)) 108 109 #ifdef BFIN_ASM 110 #include "lsp_bfin.h" 111 #endif 112 113 #else 114 115 /*#define C1 0.99940307 116 #define C2 -0.49558072 117 #define C3 0.03679168*/ 118 119 #define FREQ_SCALE 1. 120 #define ANGLE2X(a) (spx_cos(a)) 121 #define X2ANGLE(x) (acos(x)) 122 123 #endif 124 125 126 /*---------------------------------------------------------------------------*\ 127 128 FUNCTION....: cheb_poly_eva() 129 130 AUTHOR......: David Rowe 131 DATE CREATED: 24/2/93 132 133 This function evaluates a series of Chebyshev polynomials 134 135 \*---------------------------------------------------------------------------*/ 136 137 #ifdef FIXED_POINT 138 139 #ifndef OVERRIDE_CHEB_POLY_EVA 140 static inline spx_word32_t cheb_poly_eva( 141 spx_word16_t *coef, /* P or Q coefs in Q13 format */ 142 spx_word16_t x, /* cos of freq (-1.0 to 1.0) in Q14 format */ 143 int m, /* LPC order/2 */ 144 char *stack 145 ) 146 { 147 int i; 148 spx_word16_t b0, b1; 149 spx_word32_t sum; 150 151 /*Prevents overflows*/ 152 if (x>16383) 153 x = 16383; 154 if (x<-16383) 155 x = -16383; 156 157 /* Initialise values */ 158 b1=16384; 159 b0=x; 160 161 /* Evaluate Chebyshev series formulation usin g iterative approach */ 162 sum = ADD32(EXTEND32(coef[m]), EXTEND32(MULT16_16_P14(coef[m-1],x))); 163 for(i=2;i<=m;i++) 164 { 165 spx_word16_t tmp=b0; 166 b0 = SUB16(MULT16_16_Q13(x,b0), b1); 167 b1 = tmp; 168 sum = ADD32(sum, EXTEND32(MULT16_16_P14(coef[m-i],b0))); 169 } 170 171 return sum; 172 } 173 #endif 174 175 #else 176 177 static float cheb_poly_eva(spx_word32_t *coef, spx_word16_t x, int m, char *stack) 178 { 179 int k; 180 float b0, b1, tmp; 181 182 /* Initial conditions */ 183 b0=0; /* b_(m+1) */ 184 b1=0; /* b_(m+2) */ 185 186 x*=2; 187 188 /* Calculate the b_(k) */ 189 for(k=m;k>0;k--) 190 { 191 tmp=b0; /* tmp holds the previous value of b0 */ 192 b0=x*b0-b1+coef[m-k]; /* b0 holds its new value based on b0 and b1 */ 193 b1=tmp; /* b1 holds the previous value of b0 */ 194 } 195 196 return(-b1+.5*x*b0+coef[m]); 197 } 198 #endif 199 200 /*---------------------------------------------------------------------------*\ 201 202 FUNCTION....: lpc_to_lsp() 203 204 AUTHOR......: David Rowe 205 DATE CREATED: 24/2/93 206 207 This function converts LPC coefficients to LSP 208 coefficients. 209 210 \*---------------------------------------------------------------------------*/ 211 212 #ifdef FIXED_POINT 213 #define SIGN_CHANGE(a,b) (((a)&0x70000000)^((b)&0x70000000)||(b==0)) 214 #else 215 #define SIGN_CHANGE(a,b) (((a)*(b))<0.0) 216 #endif 217 218 219 int lpc_to_lsp (spx_coef_t *a,int lpcrdr,spx_lsp_t *freq,int nb,spx_word16_t delta, char *stack) 220 /* float *a lpc coefficients */ 221 /* int lpcrdr order of LPC coefficients (10) */ 222 /* float *freq LSP frequencies in the x domain */ 223 /* int nb number of sub-intervals (4) */ 224 /* float delta grid spacing interval (0.02) */ 225 226 227 { 228 spx_word16_t temp_xr,xl,xr,xm=0; 229 spx_word32_t psuml,psumr,psumm,temp_psumr/*,temp_qsumr*/; 230 int i,j,m,flag,k; 231 VARDECL(spx_word32_t *Q); /* ptrs for memory allocation */ 232 VARDECL(spx_word32_t *P); 233 VARDECL(spx_word16_t *Q16); /* ptrs for memory allocation */ 234 VARDECL(spx_word16_t *P16); 235 spx_word32_t *px; /* ptrs of respective P'(z) & Q'(z) */ 236 spx_word32_t *qx; 237 spx_word32_t *p; 238 spx_word32_t *q; 239 spx_word16_t *pt; /* ptr used for cheb_poly_eval() 240 whether P' or Q' */ 241 int roots=0; /* DR 8/2/94: number of roots found */ 242 flag = 1; /* program is searching for a root when, 243 1 else has found one */ 244 m = lpcrdr/2; /* order of P'(z) & Q'(z) polynomials */ 245 246 /* Allocate memory space for polynomials */ 247 ALLOC(Q, (m+1), spx_word32_t); 248 ALLOC(P, (m+1), spx_word32_t); 249 250 /* determine P'(z)'s and Q'(z)'s coefficients where 251 P'(z) = P(z)/(1 + z^(-1)) and Q'(z) = Q(z)/(1-z^(-1)) */ 252 253 px = P; /* initialise ptrs */ 254 qx = Q; 255 p = px; 256 q = qx; 257 258 #ifdef FIXED_POINT 259 *px++ = LPC_SCALING; 260 *qx++ = LPC_SCALING; 261 for(i=0;i<m;i++){ 262 *px++ = SUB32(ADD32(EXTEND32(a[i]),EXTEND32(a[lpcrdr-i-1])), *p++); 263 *qx++ = ADD32(SUB32(EXTEND32(a[i]),EXTEND32(a[lpcrdr-i-1])), *q++); 264 } 265 px = P; 266 qx = Q; 267 for(i=0;i<m;i++) 268 { 269 /*if (fabs(*px)>=32768) 270 speex_warning_int("px", *px); 271 if (fabs(*qx)>=32768) 272 speex_warning_int("qx", *qx);*/ 273 *px = PSHR32(*px,2); 274 *qx = PSHR32(*qx,2); 275 px++; 276 qx++; 277 } 278 /* The reason for this lies in the way cheb_poly_eva() is implemented for fixed-point */ 279 P[m] = PSHR32(P[m],3); 280 Q[m] = PSHR32(Q[m],3); 281 #else 282 *px++ = LPC_SCALING; 283 *qx++ = LPC_SCALING; 284 for(i=0;i<m;i++){ 285 *px++ = (a[i]+a[lpcrdr-1-i]) - *p++; 286 *qx++ = (a[i]-a[lpcrdr-1-i]) + *q++; 287 } 288 px = P; 289 qx = Q; 290 for(i=0;i<m;i++){ 291 *px = 2**px; 292 *qx = 2**qx; 293 px++; 294 qx++; 295 } 296 #endif 297 298 px = P; /* re-initialise ptrs */ 299 qx = Q; 300 301 /* now that we have computed P and Q convert to 16 bits to 302 speed up cheb_poly_eval */ 303 304 ALLOC(P16, m+1, spx_word16_t); 305 ALLOC(Q16, m+1, spx_word16_t); 306 307 for (i=0;i<m+1;i++) 308 { 309 P16[i] = P[i]; 310 Q16[i] = Q[i]; 311 } 312 313 /* Search for a zero in P'(z) polynomial first and then alternate to Q'(z). 314 Keep alternating between the two polynomials as each zero is found */ 315 316 xr = 0; /* initialise xr to zero */ 317 xl = FREQ_SCALE; /* start at point xl = 1 */ 318 319 for(j=0;j<lpcrdr;j++){ 320 if(j&1) /* determines whether P' or Q' is eval. */ 321 pt = Q16; 322 else 323 pt = P16; 324 325 psuml = cheb_poly_eva(pt,xl,m,stack); /* evals poly. at xl */ 326 flag = 1; 327 while(flag && (xr >= -FREQ_SCALE)){ 328 spx_word16_t dd; 329 /* Modified by JMV to provide smaller steps around x=+-1 */ 330 #ifdef FIXED_POINT 331 dd = MULT16_16_Q15(delta,SUB16(FREQ_SCALE, MULT16_16_Q14(MULT16_16_Q14(xl,xl),14000))); 332 if (psuml<512 && psuml>-512) 333 dd = PSHR16(dd,1); 334 #else 335 dd=delta*(1-.9*xl*xl); 336 if (fabs(psuml)<.2) 337 dd *= .5; 338 #endif 339 xr = SUB16(xl, dd); /* interval spacing */ 340 psumr = cheb_poly_eva(pt,xr,m,stack);/* poly(xl-delta_x) */ 341 temp_psumr = psumr; 342 temp_xr = xr; 343 344 /* if no sign change increment xr and re-evaluate poly(xr). Repeat til 345 sign change. 346 if a sign change has occurred the interval is bisected and then 347 checked again for a sign change which determines in which 348 interval the zero lies in. 349 If there is no sign change between poly(xm) and poly(xl) set interval 350 between xm and xr else set interval between xl and xr and repeat till 351 root is located within the specified limits */ 352 353 if(SIGN_CHANGE(psumr,psuml)) 354 { 355 roots++; 356 357 psumm=psuml; 358 for(k=0;k<=nb;k++){ 359 #ifdef FIXED_POINT 360 xm = ADD16(PSHR16(xl,1),PSHR16(xr,1)); /* bisect the interval */ 361 #else 362 xm = .5*(xl+xr); /* bisect the interval */ 363 #endif 364 psumm=cheb_poly_eva(pt,xm,m,stack); 365 /*if(psumm*psuml>0.)*/ 366 if(!SIGN_CHANGE(psumm,psuml)) 367 { 368 psuml=psumm; 369 xl=xm; 370 } else { 371 psumr=psumm; 372 xr=xm; 373 } 374 } 375 376 /* once zero is found, reset initial interval to xr */ 377 freq[j] = X2ANGLE(xm); 378 xl = xm; 379 flag = 0; /* reset flag for next search */ 380 } 381 else{ 382 psuml=temp_psumr; 383 xl=temp_xr; 384 } 385 } 386 } 387 return(roots); 388 } 389 390 /*---------------------------------------------------------------------------*\ 391 392 FUNCTION....: lsp_to_lpc() 393 394 AUTHOR......: David Rowe 395 DATE CREATED: 24/2/93 396 397 Converts LSP coefficients to LPC coefficients. 398 399 \*---------------------------------------------------------------------------*/ 400 401 #ifdef FIXED_POINT 402 403 void lsp_to_lpc(spx_lsp_t *freq,spx_coef_t *ak,int lpcrdr, char *stack) 404 /* float *freq array of LSP frequencies in the x domain */ 405 /* float *ak array of LPC coefficients */ 406 /* int lpcrdr order of LPC coefficients */ 407 { 408 int i,j; 409 spx_word32_t xout1,xout2,xin; 410 spx_word32_t mult, a; 411 VARDECL(spx_word16_t *freqn); 412 VARDECL(spx_word32_t **xp); 413 VARDECL(spx_word32_t *xpmem); 414 VARDECL(spx_word32_t **xq); 415 VARDECL(spx_word32_t *xqmem); 416 int m = lpcrdr>>1; 417 418 /* 419 420 Reconstruct P(z) and Q(z) by cascading second order polynomials 421 in form 1 - 2cos(w)z(-1) + z(-2), where w is the LSP frequency. 422 In the time domain this is: 423 424 y(n) = x(n) - 2cos(w)x(n-1) + x(n-2) 425 426 This is what the ALLOCS below are trying to do: 427 428 int xp[m+1][lpcrdr+1+2]; // P matrix in QIMP 429 int xq[m+1][lpcrdr+1+2]; // Q matrix in QIMP 430 431 These matrices store the output of each stage on each row. The 432 final (m-th) row has the output of the final (m-th) cascaded 433 2nd order filter. The first row is the impulse input to the 434 system (not written as it is known). 435 436 The version below takes advantage of the fact that a lot of the 437 outputs are zero or known, for example if we put an inpulse 438 into the first section the "clock" it 10 times only the first 3 439 outputs samples are non-zero (it's an FIR filter). 440 */ 441 442 ALLOC(xp, (m+1), spx_word32_t*); 443 ALLOC(xpmem, (m+1)*(lpcrdr+1+2), spx_word32_t); 444 445 ALLOC(xq, (m+1), spx_word32_t*); 446 ALLOC(xqmem, (m+1)*(lpcrdr+1+2), spx_word32_t); 447 448 for(i=0; i<=m; i++) { 449 xp[i] = xpmem + i*(lpcrdr+1+2); 450 xq[i] = xqmem + i*(lpcrdr+1+2); 451 } 452 453 /* work out 2cos terms in Q14 */ 454 455 ALLOC(freqn, lpcrdr, spx_word16_t); 456 for (i=0;i<lpcrdr;i++) 457 freqn[i] = ANGLE2X(freq[i]); 458 459 #define QIMP 21 /* scaling for impulse */ 460 461 xin = SHL32(EXTEND32(1), (QIMP-1)); /* 0.5 in QIMP format */ 462 463 /* first col and last non-zero values of each row are trivial */ 464 465 for(i=0;i<=m;i++) { 466 xp[i][1] = 0; 467 xp[i][2] = xin; 468 xp[i][2+2*i] = xin; 469 xq[i][1] = 0; 470 xq[i][2] = xin; 471 xq[i][2+2*i] = xin; 472 } 473 474 /* 2nd row (first output row) is trivial */ 475 476 xp[1][3] = -MULT16_32_Q14(freqn[0],xp[0][2]); 477 xq[1][3] = -MULT16_32_Q14(freqn[1],xq[0][2]); 478 479 xout1 = xout2 = 0; 480 481 /* now generate remaining rows */ 482 483 for(i=1;i<m;i++) { 484 485 for(j=1;j<2*(i+1)-1;j++) { 486 mult = MULT16_32_Q14(freqn[2*i],xp[i][j+1]); 487 xp[i+1][j+2] = ADD32(SUB32(xp[i][j+2], mult), xp[i][j]); 488 mult = MULT16_32_Q14(freqn[2*i+1],xq[i][j+1]); 489 xq[i+1][j+2] = ADD32(SUB32(xq[i][j+2], mult), xq[i][j]); 490 } 491 492 /* for last col xp[i][j+2] = xq[i][j+2] = 0 */ 493 494 mult = MULT16_32_Q14(freqn[2*i],xp[i][j+1]); 495 xp[i+1][j+2] = SUB32(xp[i][j], mult); 496 mult = MULT16_32_Q14(freqn[2*i+1],xq[i][j+1]); 497 xq[i+1][j+2] = SUB32(xq[i][j], mult); 498 } 499 500 /* process last row to extra a{k} */ 501 502 for(j=1;j<=lpcrdr;j++) { 503 int shift = QIMP-13; 504 505 /* final filter sections */ 506 a = PSHR32(xp[m][j+2] + xout1 + xq[m][j+2] - xout2, shift); 507 xout1 = xp[m][j+2]; 508 xout2 = xq[m][j+2]; 509 510 /* hard limit ak's to +/- 32767 */ 511 512 if (a < -32767) a = -32767; 513 if (a > 32767) a = 32767; 514 ak[j-1] = (short)a; 515 516 } 517 518 } 519 520 #else 521 522 void lsp_to_lpc(spx_lsp_t *freq,spx_coef_t *ak,int lpcrdr, char *stack) 523 /* float *freq array of LSP frequencies in the x domain */ 524 /* float *ak array of LPC coefficients */ 525 /* int lpcrdr order of LPC coefficients */ 526 527 528 { 529 int i,j; 530 float xout1,xout2,xin1,xin2; 531 VARDECL(float *Wp); 532 float *pw,*n1,*n2,*n3,*n4=NULL; 533 VARDECL(float *x_freq); 534 int m = lpcrdr>>1; 535 536 ALLOC(Wp, 4*m+2, float); 537 pw = Wp; 538 539 /* initialise contents of array */ 540 541 for(i=0;i<=4*m+1;i++){ /* set contents of buffer to 0 */ 542 *pw++ = 0.0; 543 } 544 545 /* Set pointers up */ 546 547 pw = Wp; 548 xin1 = 1.0; 549 xin2 = 1.0; 550 551 ALLOC(x_freq, lpcrdr, float); 552 for (i=0;i<lpcrdr;i++) 553 x_freq[i] = ANGLE2X(freq[i]); 554 555 /* reconstruct P(z) and Q(z) by cascading second order 556 polynomials in form 1 - 2xz(-1) +z(-2), where x is the 557 LSP coefficient */ 558 559 for(j=0;j<=lpcrdr;j++){ 560 int i2=0; 561 for(i=0;i<m;i++,i2+=2){ 562 n1 = pw+(i*4); 563 n2 = n1 + 1; 564 n3 = n2 + 1; 565 n4 = n3 + 1; 566 xout1 = xin1 - 2.f*x_freq[i2] * *n1 + *n2; 567 xout2 = xin2 - 2.f*x_freq[i2+1] * *n3 + *n4; 568 *n2 = *n1; 569 *n4 = *n3; 570 *n1 = xin1; 571 *n3 = xin2; 572 xin1 = xout1; 573 xin2 = xout2; 574 } 575 xout1 = xin1 + *(n4+1); 576 xout2 = xin2 - *(n4+2); 577 if (j>0) 578 ak[j-1] = (xout1 + xout2)*0.5f; 579 *(n4+1) = xin1; 580 *(n4+2) = xin2; 581 582 xin1 = 0.0; 583 xin2 = 0.0; 584 } 585 586 } 587 #endif 588 589 590 #ifdef FIXED_POINT 591 592 /*Makes sure the LSPs are stable*/ 593 void lsp_enforce_margin(spx_lsp_t *lsp, int len, spx_word16_t margin) 594 { 595 int i; 596 spx_word16_t m = margin; 597 spx_word16_t m2 = 25736-margin; 598 599 if (lsp[0]<m) 600 lsp[0]=m; 601 if (lsp[len-1]>m2) 602 lsp[len-1]=m2; 603 for (i=1;i<len-1;i++) 604 { 605 if (lsp[i]<lsp[i-1]+m) 606 lsp[i]=lsp[i-1]+m; 607 608 if (lsp[i]>lsp[i+1]-m) 609 lsp[i]= SHR16(lsp[i],1) + SHR16(lsp[i+1]-m,1); 610 } 611 } 612 613 614 void lsp_interpolate(spx_lsp_t *old_lsp, spx_lsp_t *new_lsp, spx_lsp_t *interp_lsp, int len, int subframe, int nb_subframes) 615 { 616 int i; 617 spx_word16_t tmp = DIV32_16(SHL32(EXTEND32(1 + subframe),14),nb_subframes); 618 spx_word16_t tmp2 = 16384-tmp; 619 for (i=0;i<len;i++) 620 { 621 interp_lsp[i] = MULT16_16_P14(tmp2,old_lsp[i]) + MULT16_16_P14(tmp,new_lsp[i]); 622 } 623 } 624 625 #else 626 627 /*Makes sure the LSPs are stable*/ 628 void lsp_enforce_margin(spx_lsp_t *lsp, int len, spx_word16_t margin) 629 { 630 int i; 631 if (lsp[0]<LSP_SCALING*margin) 632 lsp[0]=LSP_SCALING*margin; 633 if (lsp[len-1]>LSP_SCALING*(M_PI-margin)) 634 lsp[len-1]=LSP_SCALING*(M_PI-margin); 635 for (i=1;i<len-1;i++) 636 { 637 if (lsp[i]<lsp[i-1]+LSP_SCALING*margin) 638 lsp[i]=lsp[i-1]+LSP_SCALING*margin; 639 640 if (lsp[i]>lsp[i+1]-LSP_SCALING*margin) 641 lsp[i]= .5f* (lsp[i] + lsp[i+1]-LSP_SCALING*margin); 642 } 643 } 644 645 646 void lsp_interpolate(spx_lsp_t *old_lsp, spx_lsp_t *new_lsp, spx_lsp_t *interp_lsp, int len, int subframe, int nb_subframes) 647 { 648 int i; 649 float tmp = (1.0f + subframe)/nb_subframes; 650 for (i=0;i<len;i++) 651 { 652 interp_lsp[i] = (1-tmp)*old_lsp[i] + tmp*new_lsp[i]; 653 } 654 } 655 656 #endif 657
