dec_amr.cpp revision ab4412a1992ce7ec0965cdbf616d64d821b67183
1/* ------------------------------------------------------------------ 2 * Copyright (C) 1998-2009 PacketVideo 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 13 * express or implied. 14 * See the License for the specific language governing permissions 15 * and limitations under the License. 16 * ------------------------------------------------------------------- 17 */ 18/**************************************************************************************** 19Portions of this file are derived from the following 3GPP standard: 20 21 3GPP TS 26.073 22 ANSI-C code for the Adaptive Multi-Rate (AMR) speech codec 23 Available from http://www.3gpp.org 24 25(C) 2004, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TTA, TTC) 26Permission to distribute, modify and use this file under the standard license 27terms listed above has been obtained from the copyright holder. 28****************************************************************************************/ 29/* 30------------------------------------------------------------------------------ 31 32 Pathname: ./audio/gsm-amr/c/src/dec_amr.c 33 Funtions: Decoder_amr_init 34 Decoder_amr_reset 35 Decoder_amr 36 37------------------------------------------------------------------------------ 38 MODULE DESCRIPTION 39 40 This file contains the function used to decode one speech frame using a given 41 codec mode. The functions used to initialize, reset, and exit are also 42 included in this file. 43 44------------------------------------------------------------------------------ 45*/ 46 47/*---------------------------------------------------------------------------- 48; INCLUDES 49----------------------------------------------------------------------------*/ 50#include <string.h> 51 52#include "dec_amr.h" 53#include "typedef.h" 54#include "cnst.h" 55#include "copy.h" 56#include "set_zero.h" 57#include "syn_filt.h" 58#include "d_plsf.h" 59#include "agc.h" 60#include "int_lpc.h" 61#include "dec_gain.h" 62#include "dec_lag3.h" 63#include "dec_lag6.h" 64#include "d2_9pf.h" 65#include "d2_11pf.h" 66#include "d3_14pf.h" 67#include "d4_17pf.h" 68#include "d8_31pf.h" 69#include "d1035pf.h" 70#include "pred_lt.h" 71#include "d_gain_p.h" 72#include "d_gain_c.h" 73#include "dec_gain.h" 74#include "ec_gains.h" 75#include "ph_disp.h" 76#include "c_g_aver.h" 77#include "int_lsf.h" 78#include "lsp_lsf.h" 79#include "lsp_avg.h" 80#include "bgnscd.h" 81#include "ex_ctrl.h" 82#include "sqrt_l.h" 83#include "frame.h" 84#include "bitno_tab.h" 85#include "b_cn_cod.h" 86#include "basic_op.h" 87 88/*---------------------------------------------------------------------------- 89; MACROS 90; Define module specific macros here 91----------------------------------------------------------------------------*/ 92 93/*---------------------------------------------------------------------------- 94; DEFINES 95; Include all pre-processor statements here. Include conditional 96; compile variables also. 97----------------------------------------------------------------------------*/ 98 99/*---------------------------------------------------------------------------- 100; LOCAL FUNCTION DEFINITIONS 101; Function Prototype declaration 102----------------------------------------------------------------------------*/ 103 104/*---------------------------------------------------------------------------- 105; LOCAL VARIABLE DEFINITIONS 106; Variable declaration - defined here and used outside this module 107----------------------------------------------------------------------------*/ 108 109 110/* 111------------------------------------------------------------------------------ 112 FUNCTION NAME: Decoder_amr_init 113------------------------------------------------------------------------------ 114 INPUT AND OUTPUT DEFINITIONS 115 116 Inputs: 117 state = pointer to a pointer to structures of type Decoder_amrState 118 119 Outputs: 120 structure pointed to by the pointer which is pointed to by state is 121 initialized to each field's initial values 122 123 state pointer points to the address of the memory allocated by 124 Decoder_amr_init function 125 126 Returns: 127 return_value = 0, if the initialization was successful; -1, otherwise (int) 128 129 Global Variables Used: 130 None 131 132 Local Variables Needed: 133 None 134 135------------------------------------------------------------------------------ 136 FUNCTION DESCRIPTION 137 138 This function allocates and initializes state memory used by the Decoder_amr 139 function. It stores the pointer to the filter status structure in state. This 140 pointer has to be passed to Decoder_amr in each call. The function returns 141 0, if initialization was successful and -1, otherwise. 142 143------------------------------------------------------------------------------ 144 REQUIREMENTS 145 146 None 147 148------------------------------------------------------------------------------ 149 REFERENCES 150 151 dec_amr.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001 152 153------------------------------------------------------------------------------ 154 PSEUDO-CODE 155 156int Decoder_amr_init (Decoder_amrState **state) 157{ 158 Decoder_amrState* s; 159 Word16 i; 160 161 if (state == (Decoder_amrState **) NULL){ 162 fprintf(stderr, "Decoder_amr_init: invalid parameter\n"); 163 return -1; 164 } 165 *state = NULL; 166 167 // allocate memory 168 if ((s= (Decoder_amrState *) malloc(sizeof(Decoder_amrState))) == NULL){ 169 fprintf(stderr, "Decoder_amr_init: can not malloc state structure\n"); 170 return -1; 171 } 172 173 s->T0_lagBuff = 40; 174 s->inBackgroundNoise = 0; 175 s->voicedHangover = 0; 176 for (i = 0; i < 9; i++) 177 s->ltpGainHistory[i] = 0; 178 179 s->lsfState = NULL; 180 s->ec_gain_p_st = NULL; 181 s->ec_gain_c_st = NULL; 182 s->pred_state = NULL; 183 s->ph_disp_st = NULL; 184 s->dtxDecoderState = NULL; 185 186 if (D_plsf_init(&s->lsfState) || 187 ec_gain_pitch_init(&s->ec_gain_p_st) || 188 ec_gain_code_init(&s->ec_gain_c_st) || 189 gc_pred_init(&s->pred_state) || 190 Cb_gain_average_init(&s->Cb_gain_averState) || 191 lsp_avg_init(&s->lsp_avg_st) || 192 Bgn_scd_init(&s->background_state) || 193 ph_disp_init(&s->ph_disp_st) || 194 dtx_dec_init(&s->dtxDecoderState)) { 195 Decoder_amr_exit(&s); 196 return -1; 197 } 198 199 Decoder_amr_reset(s, (enum Mode)0); 200 *state = s; 201 202 return 0; 203} 204 205------------------------------------------------------------------------------ 206 RESOURCES USED [optional] 207 208 When the code is written for a specific target processor the 209 the resources used should be documented below. 210 211 HEAP MEMORY USED: x bytes 212 213 STACK MEMORY USED: x bytes 214 215 CLOCK CYCLES: (cycle count equation for this function) + (variable 216 used to represent cycle count for each subroutine 217 called) 218 where: (cycle count variable) = cycle count for [subroutine 219 name] 220 221------------------------------------------------------------------------------ 222 CAUTION [optional] 223 [State any special notes, constraints or cautions for users of this function] 224 225------------------------------------------------------------------------------ 226*/ 227 228Word16 Decoder_amr_init(Decoder_amrState *s) 229{ 230 Word16 i; 231 232 if (s == (Decoder_amrState *) NULL) 233 { 234 /* fprint(stderr, "Decoder_amr_init: invalid parameter\n"); */ 235 return(-1); 236 } 237 238 s->T0_lagBuff = 40; 239 s->inBackgroundNoise = 0; 240 s->voicedHangover = 0; 241 242 /* Initialize overflow Flag */ 243 244 s->overflow = 0; 245 246 for (i = 0; i < LTP_GAIN_HISTORY_LEN; i++) 247 { 248 s->ltpGainHistory[i] = 0; 249 } 250 251 D_plsf_reset(&s->lsfState); 252 ec_gain_pitch_reset(&s->ec_gain_p_st); 253 ec_gain_code_reset(&s->ec_gain_c_st); 254 Cb_gain_average_reset(&s->Cb_gain_averState); 255 lsp_avg_reset(&s->lsp_avg_st); 256 Bgn_scd_reset(&s->background_state); 257 ph_disp_reset(&s->ph_disp_st); 258 dtx_dec_reset(&s->dtxDecoderState); 259 gc_pred_reset(&s->pred_state); 260 261 Decoder_amr_reset(s, MR475); 262 263 return(0); 264} 265 266/****************************************************************************/ 267 268/* 269------------------------------------------------------------------------------ 270 FUNCTION NAME: Decoder_amr_reset 271------------------------------------------------------------------------------ 272 INPUT AND OUTPUT DEFINITIONS 273 274 Inputs: 275 state = pointer to a structure of type Decoder_amrState 276 mode = codec mode (enum Mode) 277 278 Outputs: 279 structure pointed to by state is initialized to its reset value 280 281 Returns: 282 return_value = 0, if reset was successful; -1, otherwise (int) 283 284 Global Variables Used: 285 None 286 287 Local Variables Needed: 288 None 289 290------------------------------------------------------------------------------ 291 FUNCTION DESCRIPTION 292 293 This function resets the state memory used by the Decoder_amr function. It 294 returns a 0, if reset was successful and -1, otherwise. 295 296------------------------------------------------------------------------------ 297 REQUIREMENTS 298 299 None 300 301------------------------------------------------------------------------------ 302 REFERENCES 303 304 dec_amr.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001 305 306------------------------------------------------------------------------------ 307 PSEUDO-CODE 308 309int Decoder_amr_reset (Decoder_amrState *state, enum Mode mode) 310{ 311 Word16 i; 312 313 if (state == (Decoder_amrState *) NULL){ 314 fprintf(stderr, "Decoder_amr_reset: invalid parameter\n"); 315 return -1; 316 } 317 318 // Initialize static pointer 319 state->exc = state->old_exc + PIT_MAX + L_INTERPOL; 320 321 // Static vectors to zero 322 Set_zero (state->old_exc, PIT_MAX + L_INTERPOL); 323 324 if (mode != MRDTX) 325 Set_zero (state->mem_syn, M); 326 327 // initialize pitch sharpening 328 state->sharp = SHARPMIN; 329 state->old_T0 = 40; 330 331 // Initialize state->lsp_old [] 332 333 if (mode != MRDTX) { 334 Copy(lsp_init_data, &state->lsp_old[0], M); 335 } 336 337 // Initialize memories of bad frame handling 338 state->prev_bf = 0; 339 state->prev_pdf = 0; 340 state->state = 0; 341 342 state->T0_lagBuff = 40; 343 state->inBackgroundNoise = 0; 344 state->voicedHangover = 0; 345 if (mode != MRDTX) { 346 for (i=0;i<9;i++) 347 state->excEnergyHist[i] = 0; 348 } 349 350 for (i = 0; i < 9; i++) 351 state->ltpGainHistory[i] = 0; 352 353 Cb_gain_average_reset(state->Cb_gain_averState); 354 if (mode != MRDTX) 355 lsp_avg_reset(state->lsp_avg_st); 356 D_plsf_reset(state->lsfState); 357 ec_gain_pitch_reset(state->ec_gain_p_st); 358 ec_gain_code_reset(state->ec_gain_c_st); 359 360 if (mode != MRDTX) 361 gc_pred_reset(state->pred_state); 362 363 Bgn_scd_reset(state->background_state); 364 state->nodataSeed = 21845; 365 ph_disp_reset(state->ph_disp_st); 366 if (mode != MRDTX) 367 dtx_dec_reset(state->dtxDecoderState); 368 369 return 0; 370} 371 372------------------------------------------------------------------------------ 373 RESOURCES USED [optional] 374 375 When the code is written for a specific target processor the 376 the resources used should be documented below. 377 378 HEAP MEMORY USED: x bytes 379 380 STACK MEMORY USED: x bytes 381 382 CLOCK CYCLES: (cycle count equation for this function) + (variable 383 used to represent cycle count for each subroutine 384 called) 385 where: (cycle count variable) = cycle count for [subroutine 386 name] 387 388------------------------------------------------------------------------------ 389 CAUTION [optional] 390 [State any special notes, constraints or cautions for users of this function] 391 392------------------------------------------------------------------------------ 393*/ 394 395Word16 Decoder_amr_reset(Decoder_amrState *state, enum Mode mode) 396{ 397 Word16 i; 398 399 if (state == (Decoder_amrState *) NULL) 400 { 401 /* fprint(stderr, "Decoder_amr_reset: invalid parameter\n"); */ 402 return(-1); 403 } 404 405 /* Initialize static pointer */ 406 state->exc = state->old_exc + PIT_MAX + L_INTERPOL; 407 408 /* Static vectors to zero */ 409 memset(state->old_exc, 0, sizeof(Word16)*(PIT_MAX + L_INTERPOL)); 410 411 if (mode != MRDTX) 412 { 413 memset(state->mem_syn, 0, sizeof(Word16)*M); 414 } 415 /* initialize pitch sharpening */ 416 state->sharp = SHARPMIN; 417 state->old_T0 = 40; 418 419 /* Initialize overflow Flag */ 420 421 state->overflow = 0; 422 423 /* Initialize state->lsp_old [] */ 424 425 if (mode != MRDTX) 426 { 427 state->lsp_old[0] = 30000; 428 state->lsp_old[1] = 26000; 429 state->lsp_old[2] = 21000; 430 state->lsp_old[3] = 15000; 431 state->lsp_old[4] = 8000; 432 state->lsp_old[5] = 0; 433 state->lsp_old[6] = -8000; 434 state->lsp_old[7] = -15000; 435 state->lsp_old[8] = -21000; 436 state->lsp_old[9] = -26000; 437 } 438 439 /* Initialize memories of bad frame handling */ 440 state->prev_bf = 0; 441 state->prev_pdf = 0; 442 state->state = 0; 443 444 state->T0_lagBuff = 40; 445 state->inBackgroundNoise = 0; 446 state->voicedHangover = 0; 447 if (mode != MRDTX) 448 { 449 for (i = 0; i < EXC_ENERGY_HIST_LEN; i++) 450 { 451 state->excEnergyHist[i] = 0; 452 } 453 } 454 455 for (i = 0; i < LTP_GAIN_HISTORY_LEN; i++) 456 { 457 state->ltpGainHistory[i] = 0; 458 } 459 460 Cb_gain_average_reset(&(state->Cb_gain_averState)); 461 if (mode != MRDTX) 462 { 463 lsp_avg_reset(&(state->lsp_avg_st)); 464 } 465 D_plsf_reset(&(state->lsfState)); 466 ec_gain_pitch_reset(&(state->ec_gain_p_st)); 467 ec_gain_code_reset(&(state->ec_gain_c_st)); 468 469 if (mode != MRDTX) 470 { 471 gc_pred_reset(&(state->pred_state)); 472 } 473 474 Bgn_scd_reset(&(state->background_state)); 475 state->nodataSeed = 21845; 476 ph_disp_reset(&(state->ph_disp_st)); 477 if (mode != MRDTX) 478 { 479 dtx_dec_reset(&(state->dtxDecoderState)); 480 } 481 482 return(0); 483} 484 485/****************************************************************************/ 486 487/* 488------------------------------------------------------------------------------ 489 FUNCTION NAME: Decoder_amr 490------------------------------------------------------------------------------ 491 INPUT AND OUTPUT DEFINITIONS 492 493 Inputs: 494 st = pointer to a structure of type Decoder_amrState 495 mode = codec mode (enum Mode) 496 parm = buffer of synthesis parameters (Word16) 497 frame_type = received frame type (enum RXFrameType) 498 synth = buffer containing synthetic speech (Word16) 499 A_t = buffer containing decoded LP filter in 4 subframes (Word16) 500 501 Outputs: 502 structure pointed to by st contains the newly calculated decoder 503 parameters 504 synth buffer contains the decoded speech samples 505 A_t buffer contains the decoded LP filter parameters 506 507 Returns: 508 return_value = 0 (int) 509 510 Global Variables Used: 511 None 512 513 Local Variables Needed: 514 None 515 516------------------------------------------------------------------------------ 517 FUNCTION DESCRIPTION 518 519 This function performs the decoding of one speech frame for a given codec 520 mode. 521 522------------------------------------------------------------------------------ 523 REQUIREMENTS 524 525 None 526 527------------------------------------------------------------------------------ 528 REFERENCES 529 530 dec_amr.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001 531 532------------------------------------------------------------------------------ 533 PSEUDO-CODE 534 535int Decoder_amr ( 536 Decoder_amrState *st, // i/o : State variables 537 enum Mode mode, // i : AMR mode 538 Word16 parm[], // i : vector of synthesis parameters 539 (PRM_SIZE) 540 enum RXFrameType frame_type, // i : received frame type 541 Word16 synth[], // o : synthesis speech (L_FRAME) 542 Word16 A_t[] // o : decoded LP filter in 4 subframes 543 (AZ_SIZE) 544) 545{ 546 // LPC coefficients 547 548 Word16 *Az; // Pointer on A_t 549 550 // LSPs 551 552 Word16 lsp_new[M]; 553 Word16 lsp_mid[M]; 554 555 // LSFs 556 557 Word16 prev_lsf[M]; 558 Word16 lsf_i[M]; 559 560 // Algebraic codevector 561 562 Word16 code[L_SUBFR]; 563 564 // excitation 565 566 Word16 excp[L_SUBFR]; 567 Word16 exc_enhanced[L_SUBFR]; 568 569 // Scalars 570 571 Word16 i, i_subfr; 572 Word16 T0, T0_frac, index, index_mr475 = 0; 573 Word16 gain_pit, gain_code, gain_code_mix, pit_sharp, pit_flag, pitch_fac; 574 Word16 t0_min, t0_max; 575 Word16 delta_frc_low, delta_frc_range; 576 Word16 tmp_shift; 577 Word16 temp; 578 Word32 L_temp; 579 Word16 flag4; 580 Word16 carefulFlag; 581 Word16 excEnergy; 582 Word16 subfrNr; 583 Word16 evenSubfr = 0; 584 585 Word16 bfi = 0; // bad frame indication flag 586 Word16 pdfi = 0; // potential degraded bad frame flag 587 588 enum DTXStateType newDTXState; // SPEECH , DTX, DTX_MUTE 589 590 // find the new DTX state SPEECH OR DTX 591 newDTXState = rx_dtx_handler(st->dtxDecoderState, frame_type); 592 593 // DTX actions 594 if (sub(newDTXState, SPEECH) != 0 ) 595 { 596 Decoder_amr_reset (st, MRDTX); 597 598 dtx_dec(st->dtxDecoderState, 599 st->mem_syn, 600 st->lsfState, 601 st->pred_state, 602 st->Cb_gain_averState, 603 newDTXState, 604 mode, 605 parm, synth, A_t); 606 // update average lsp 607 608 Lsf_lsp(st->lsfState->past_lsf_q, st->lsp_old, M); 609 lsp_avg(st->lsp_avg_st, st->lsfState->past_lsf_q); 610 goto the_end; 611 } 612 613 // SPEECH action state machine 614 if ((sub(frame_type, RX_SPEECH_BAD) == 0) || 615 (sub(frame_type, RX_NO_DATA) == 0) || 616 (sub(frame_type, RX_ONSET) == 0)) 617 { 618 bfi = 1; 619 if ((sub(frame_type, RX_NO_DATA) == 0) || 620 (sub(frame_type, RX_ONSET) == 0)) 621 { 622 build_CN_param(&st->nodataSeed, 623 prmno[mode], 624 bitno[mode], 625 parm); 626 } 627 } 628 else if (sub(frame_type, RX_SPEECH_DEGRADED) == 0) 629 { 630 pdfi = 1; 631 } 632 633 if (bfi != 0) 634 { 635 st->state = add (st->state, 1); 636 } 637 else if (sub (st->state, 6) == 0) 638 639 { 640 st->state = 5; 641 } 642 else 643 { 644 st->state = 0; 645 } 646 647 if (sub (st->state, 6) > 0) 648 { 649 st->state = 6; 650 } 651 652 // If this frame is the first speech frame after CNI period, 653 // set the BFH state machine to an appropriate state depending 654 // on whether there was DTX muting before start of speech or not 655 // If there was DTX muting, the first speech frame is muted. 656 // If there was no DTX muting, the first speech frame is not 657 // muted. The BFH state machine starts from state 5, however, to 658 // keep the audible noise resulting from a SID frame which is 659 // erroneously interpreted as a good speech frame as small as 660 // possible (the decoder output in this case is quickly muted) 661 662 if (sub(st->dtxDecoderState->dtxGlobalState, DTX) == 0) 663 { 664 st->state = 5; 665 st->prev_bf = 0; 666 } 667 else if (sub(st->dtxDecoderState->dtxGlobalState, DTX_MUTE) == 0) 668 { 669 st->state = 5; 670 st->prev_bf = 1; 671 } 672 673 // save old LSFs for CB gain smoothing 674 Copy (st->lsfState->past_lsf_q, prev_lsf, M); 675 676 // decode LSF parameters and generate interpolated lpc coefficients 677 for the 4 subframes 678 if (sub (mode, MR122) != 0) 679 { 680 D_plsf_3(st->lsfState, mode, bfi, parm, lsp_new); 681 682 // Advance synthesis parameters pointer 683 parm += 3; 684 685 Int_lpc_1to3(st->lsp_old, lsp_new, A_t); 686 } 687 else 688 { 689 D_plsf_5 (st->lsfState, bfi, parm, lsp_mid, lsp_new); 690 691 // Advance synthesis parameters pointer 692 parm += 5; 693 694 Int_lpc_1and3 (st->lsp_old, lsp_mid, lsp_new, A_t); 695 } 696 697 // update the LSPs for the next frame 698 for (i = 0; i < M; i++) 699 { 700 st->lsp_old[i] = lsp_new[i]; 701 } 702 703 *------------------------------------------------------------------------* 704 * Loop for every subframe in the analysis frame * 705 *------------------------------------------------------------------------* 706 * The subframe size is L_SUBFR and the loop is repeated L_FRAME/L_SUBFR * 707 * times * 708 * - decode the pitch delay * 709 * - decode algebraic code * 710 * - decode pitch and codebook gains * 711 * - find the excitation and compute synthesis speech * 712 *------------------------------------------------------------------------* 713 714 // pointer to interpolated LPC parameters 715 Az = A_t; 716 717 evenSubfr = 0; 718 subfrNr = -1; 719 for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR) 720 { 721 subfrNr = add(subfrNr, 1); 722 evenSubfr = sub(1, evenSubfr); 723 724 // flag for first and 3th subframe 725 pit_flag = i_subfr; 726 727 if (sub (i_subfr, L_FRAME_BY2) == 0) 728 { 729 if (sub(mode, MR475) != 0 && sub(mode, MR515) != 0) 730 { 731 pit_flag = 0; 732 } 733 } 734 735 // pitch index 736 index = *parm++; 737 738 *-------------------------------------------------------* 739 * - decode pitch lag and find adaptive codebook vector. * 740 *-------------------------------------------------------* 741 742 if (sub(mode, MR122) != 0) 743 { 744 // flag4 indicates encoding with 4 bit resolution; 745 // this is needed for mode MR475, MR515, MR59 and MR67 746 747 flag4 = 0; 748 if ((sub (mode, MR475) == 0) || 749 (sub (mode, MR515) == 0) || 750 (sub (mode, MR59) == 0) || 751 (sub (mode, MR67) == 0) ) { 752 flag4 = 1; 753 } 754 755 *-------------------------------------------------------* 756 * - get ranges for the t0_min and t0_max * 757 * - only needed in delta decoding * 758 *-------------------------------------------------------* 759 760 delta_frc_low = 5; 761 delta_frc_range = 9; 762 763 if ( sub(mode, MR795) == 0 ) 764 { 765 delta_frc_low = 10; 766 delta_frc_range = 19; 767 } 768 769 t0_min = sub(st->old_T0, delta_frc_low); 770 if (sub(t0_min, PIT_MIN) < 0) 771 { 772 t0_min = PIT_MIN; 773 } 774 t0_max = add(t0_min, delta_frc_range); 775 if (sub(t0_max, PIT_MAX) > 0) 776 { 777 t0_max = PIT_MAX; 778 t0_min = sub(t0_max, delta_frc_range); 779 } 780 781 Dec_lag3 (index, t0_min, t0_max, pit_flag, st->old_T0, 782 &T0, &T0_frac, flag4); 783 784 st->T0_lagBuff = T0; 785 786 if (bfi != 0) 787 { 788 if (sub (st->old_T0, PIT_MAX) < 0) 789 { // Graceful pitch 790 st->old_T0 = add(st->old_T0, 1); // degradation 791 } 792 T0 = st->old_T0; 793 T0_frac = 0; 794 795 if ( st->inBackgroundNoise != 0 && 796 sub(st->voicedHangover, 4) > 0 && 797 ((sub(mode, MR475) == 0 ) || 798 (sub(mode, MR515) == 0 ) || 799 (sub(mode, MR59) == 0) ) 800 ) 801 { 802 T0 = st->T0_lagBuff; 803 } 804 } 805 806 Pred_lt_3or6 (st->exc, T0, T0_frac, L_SUBFR, 1); 807 } 808 else 809 { 810 Dec_lag6 (index, PIT_MIN_MR122, 811 PIT_MAX, pit_flag, &T0, &T0_frac); 812 813 if ( bfi == 0 && (pit_flag == 0 || sub (index, 61) < 0)) 814 { 815 } 816 else 817 { 818 st->T0_lagBuff = T0; 819 T0 = st->old_T0; 820 T0_frac = 0; 821 } 822 823 Pred_lt_3or6 (st->exc, T0, T0_frac, L_SUBFR, 0); 824 } 825 826 *-------------------------------------------------------* 827 * - (MR122 only: Decode pitch gain.) * 828 * - Decode innovative codebook. * 829 * - set pitch sharpening factor * 830 *-------------------------------------------------------* 831 832 if (sub (mode, MR475) == 0 || sub (mode, MR515) == 0) 833 { // MR475, MR515 834 index = *parm++; // index of position 835 i = *parm++; // signs 836 837 decode_2i40_9bits (subfrNr, i, index, code); 838 839 pit_sharp = shl (st->sharp, 1); 840 } 841 else if (sub (mode, MR59) == 0) 842 { // MR59 843 index = *parm++; // index of position 844 i = *parm++; // signs 845 846 decode_2i40_11bits (i, index, code); 847 848 pit_sharp = shl (st->sharp, 1); 849 } 850 else if (sub (mode, MR67) == 0) 851 { // MR67 852 index = *parm++; // index of position 853 i = *parm++; // signs 854 855 decode_3i40_14bits (i, index, code); 856 857 pit_sharp = shl (st->sharp, 1); 858 } 859 else if (sub (mode, MR795) <= 0) 860 { // MR74, MR795 861 index = *parm++; // index of position 862 i = *parm++; // signs 863 864 decode_4i40_17bits (i, index, code); 865 866 pit_sharp = shl (st->sharp, 1); 867 } 868 else if (sub (mode, MR102) == 0) 869 { // MR102 870 dec_8i40_31bits (parm, code); 871 parm += 7; 872 873 pit_sharp = shl (st->sharp, 1); 874 } 875 else 876 { // MR122 877 index = *parm++; 878 if (bfi != 0) 879 { 880 ec_gain_pitch (st->ec_gain_p_st, st->state, &gain_pit); 881 } 882 else 883 { 884 gain_pit = d_gain_pitch (mode, index); 885 } 886 ec_gain_pitch_update (st->ec_gain_p_st, bfi, st->prev_bf, 887 &gain_pit); 888 889 dec_10i40_35bits (parm, code); 890 parm += 10; 891 892 // pit_sharp = gain_pit; 893 // if (pit_sharp > 1.0) pit_sharp = 1.0; 894 895 pit_sharp = shl (gain_pit, 1); 896 } 897 898 *-------------------------------------------------------* 899 * - Add the pitch contribution to code[]. * 900 *-------------------------------------------------------* 901 for (i = T0; i < L_SUBFR; i++) 902 { 903 temp = mult (code[i - T0], pit_sharp); 904 code[i] = add (code[i], temp); 905 } 906 907 *------------------------------------------------------------* 908 * - Decode codebook gain (MR122) or both pitch * 909 * gain and codebook gain (all others) * 910 * - Update pitch sharpening "sharp" with quantized gain_pit * 911 *------------------------------------------------------------* 912 913 if (sub (mode, MR475) == 0) 914 { 915 // read and decode pitch and code gain 916 if (evenSubfr != 0) 917 { 918 index_mr475 = *parm++; // index of gain(s) 919 } 920 921 if (bfi == 0) 922 { 923 Dec_gain(st->pred_state, mode, index_mr475, code, 924 evenSubfr, &gain_pit, &gain_code); 925 } 926 else 927 { 928 ec_gain_pitch (st->ec_gain_p_st, st->state, &gain_pit); 929 ec_gain_code (st->ec_gain_c_st, st->pred_state, st->state, 930 &gain_code); 931 } 932 ec_gain_pitch_update (st->ec_gain_p_st, bfi, st->prev_bf, 933 &gain_pit); 934 ec_gain_code_update (st->ec_gain_c_st, bfi, st->prev_bf, 935 &gain_code); 936 937 pit_sharp = gain_pit; 938 if (sub (pit_sharp, SHARPMAX) > 0) 939 { 940 pit_sharp = SHARPMAX; 941 } 942 943 } 944 else if ((sub (mode, MR74) <= 0) || 945 (sub (mode, MR102) == 0)) 946 { 947 // read and decode pitch and code gain 948 index = *parm++; // index of gain(s) 949 950 if (bfi == 0) 951 { 952 Dec_gain(st->pred_state, mode, index, code, 953 evenSubfr, &gain_pit, &gain_code); 954 } 955 else 956 { 957 ec_gain_pitch (st->ec_gain_p_st, st->state, &gain_pit); 958 ec_gain_code (st->ec_gain_c_st, st->pred_state, st->state, 959 &gain_code); 960 } 961 ec_gain_pitch_update (st->ec_gain_p_st, bfi, st->prev_bf, 962 &gain_pit); 963 ec_gain_code_update (st->ec_gain_c_st, bfi, st->prev_bf, 964 &gain_code); 965 966 pit_sharp = gain_pit; 967 if (sub (pit_sharp, SHARPMAX) > 0) 968 { 969 pit_sharp = SHARPMAX; 970 } 971 972 if (sub (mode, MR102) == 0) 973 { 974 if (sub (st->old_T0, add(L_SUBFR, 5)) > 0) 975 { 976 pit_sharp = shr(pit_sharp, 2); 977 } 978 } 979 } 980 else 981 { 982 // read and decode pitch gain 983 index = *parm++; // index of gain(s) 984 985 if (sub (mode, MR795) == 0) 986 { 987 // decode pitch gain 988 if (bfi != 0) 989 { 990 ec_gain_pitch (st->ec_gain_p_st, st->state, &gain_pit); 991 } 992 else 993 { 994 gain_pit = d_gain_pitch (mode, index); 995 } 996 ec_gain_pitch_update (st->ec_gain_p_st, bfi, st->prev_bf, 997 &gain_pit); 998 999 // read and decode code gain 1000 index = *parm++; 1001 if (bfi == 0) 1002 { 1003 d_gain_code (st->pred_state, mode, index, code, &gain_code); 1004 } 1005 else 1006 { 1007 ec_gain_code (st->ec_gain_c_st, st->pred_state, st->state, 1008 &gain_code); 1009 } 1010 ec_gain_code_update (st->ec_gain_c_st, bfi, st->prev_bf, 1011 &gain_code); 1012 1013 pit_sharp = gain_pit; 1014 if (sub (pit_sharp, SHARPMAX) > 0) 1015 { 1016 pit_sharp = SHARPMAX; 1017 } 1018 } 1019 else 1020 { // MR122 1021 if (bfi == 0) 1022 { 1023 d_gain_code (st->pred_state, mode, index, code, &gain_code); 1024 } 1025 else 1026 { 1027 ec_gain_code (st->ec_gain_c_st, st->pred_state, st->state, 1028 &gain_code); 1029 } 1030 ec_gain_code_update (st->ec_gain_c_st, bfi, st->prev_bf, 1031 &gain_code); 1032 1033 pit_sharp = gain_pit; 1034 } 1035 } 1036 1037 // store pitch sharpening for next subframe 1038 // (for modes which use the previous pitch gain for 1039 // pitch sharpening in the search phase) 1040 // do not update sharpening in even subframes for MR475 1041 if (sub(mode, MR475) != 0 || evenSubfr == 0) 1042 { 1043 st->sharp = gain_pit; 1044 if (sub (st->sharp, SHARPMAX) > 0) 1045 { 1046 st->sharp = SHARPMAX; 1047 } 1048 } 1049 1050 pit_sharp = shl (pit_sharp, 1); 1051 if (sub (pit_sharp, 16384) > 0) 1052 { 1053 for (i = 0; i < L_SUBFR; i++) 1054 { 1055 temp = mult (st->exc[i], pit_sharp); 1056 L_temp = L_mult (temp, gain_pit); 1057 if (sub(mode, MR122)==0) 1058 { 1059 L_temp = L_shr (L_temp, 1); 1060 } 1061 excp[i] = pv_round (L_temp); 1062 } 1063 } 1064 1065 *-------------------------------------------------------* 1066 * - Store list of LTP gains needed in the source * 1067 * characteristic detector (SCD) * 1068 *-------------------------------------------------------* 1069 if ( bfi == 0 ) 1070 { 1071 for (i = 0; i < 8; i++) 1072 { 1073 st->ltpGainHistory[i] = st->ltpGainHistory[i+1]; 1074 } 1075 st->ltpGainHistory[8] = gain_pit; 1076 } 1077 1078 *-------------------------------------------------------* 1079 * - Limit gain_pit if in background noise and BFI * 1080 * for MR475, MR515, MR59 * 1081 *-------------------------------------------------------* 1082 1083 if ( (st->prev_bf != 0 || bfi != 0) && st->inBackgroundNoise != 0 && 1084 ((sub(mode, MR475) == 0) || 1085 (sub(mode, MR515) == 0) || 1086 (sub(mode, MR59) == 0)) 1087 ) 1088 { 1089 if ( sub (gain_pit, 12288) > 0) // if (gain_pit > 0.75) in Q14 1090 gain_pit = add( shr( sub(gain_pit, 12288), 1 ), 12288 ); 1091 // gain_pit = (gain_pit-0.75)/2.0 + 0.75; 1092 1093 if ( sub (gain_pit, 14745) > 0) // if (gain_pit > 0.90) in Q14 1094 { 1095 gain_pit = 14745; 1096 } 1097 } 1098 1099 *-------------------------------------------------------* 1100 * Calculate CB mixed gain * 1101 *-------------------------------------------------------* 1102 Int_lsf(prev_lsf, st->lsfState->past_lsf_q, i_subfr, lsf_i); 1103 gain_code_mix = Cb_gain_average( 1104 st->Cb_gain_averState, mode, gain_code, 1105 lsf_i, st->lsp_avg_st->lsp_meanSave, bfi, 1106 st->prev_bf, pdfi, st->prev_pdf, 1107 st->inBackgroundNoise, st->voicedHangover); 1108 1109 // make sure that MR74, MR795, MR122 have original code_gain 1110 if ((sub(mode, MR67) > 0) && (sub(mode, MR102) != 0) ) 1111 // MR74, MR795, MR122 1112 { 1113 gain_code_mix = gain_code; 1114 } 1115 1116 *-------------------------------------------------------* 1117 * - Find the total excitation. * 1118 * - Find synthesis speech corresponding to st->exc[]. * 1119 *-------------------------------------------------------* 1120 if (sub(mode, MR102) <= 0) // MR475, MR515, MR59, MR67, MR74, MR795, MR102 1121 { 1122 pitch_fac = gain_pit; 1123 tmp_shift = 1; 1124 } 1125 else // MR122 1126 { 1127 pitch_fac = shr (gain_pit, 1); 1128 tmp_shift = 2; 1129 } 1130 1131 // copy unscaled LTP excitation to exc_enhanced (used in phase 1132 * dispersion below) and compute total excitation for LTP feedback 1133 1134 for (i = 0; i < L_SUBFR; i++) 1135 { 1136 exc_enhanced[i] = st->exc[i]; 1137 1138 // st->exc[i] = gain_pit*st->exc[i] + gain_code*code[i]; 1139 L_temp = L_mult (st->exc[i], pitch_fac); 1140 // 12.2: Q0 * Q13 1141 // 7.4: Q0 * Q14 1142 L_temp = L_mac (L_temp, code[i], gain_code); 1143 // 12.2: Q12 * Q1 1144 // 7.4: Q13 * Q1 1145 L_temp = L_shl (L_temp, tmp_shift); // Q16 1146 st->exc[i] = pv_round (L_temp); 1147 } 1148 1149 *-------------------------------------------------------* 1150 * - Adaptive phase dispersion * 1151 *-------------------------------------------------------* 1152 ph_disp_release(st->ph_disp_st); // free phase dispersion adaption 1153 1154 if ( ((sub(mode, MR475) == 0) || 1155 (sub(mode, MR515) == 0) || 1156 (sub(mode, MR59) == 0)) && 1157 sub(st->voicedHangover, 3) > 0 && 1158 st->inBackgroundNoise != 0 && 1159 bfi != 0 ) 1160 { 1161 ph_disp_lock(st->ph_disp_st); // Always Use full Phase Disp. 1162 } // if error in bg noise 1163 1164 // apply phase dispersion to innovation (if enabled) and 1165 compute total excitation for synthesis part 1166 ph_disp(st->ph_disp_st, mode, 1167 exc_enhanced, gain_code_mix, gain_pit, code, 1168 pitch_fac, tmp_shift); 1169 1170 *-------------------------------------------------------* 1171 * - The Excitation control module are active during BFI.* 1172 * - Conceal drops in signal energy if in bg noise. * 1173 *-------------------------------------------------------* 1174 1175 L_temp = 0; 1176 for (i = 0; i < L_SUBFR; i++) 1177 { 1178 L_temp = L_mac (L_temp, exc_enhanced[i], exc_enhanced[i] ); 1179 } 1180 1181 L_temp = L_shr (L_temp, 1); // excEnergy = sqrt(L_temp) in Q0 1182 L_temp = sqrt_l_exp(L_temp, &temp); // function result 1183 L_temp = L_shr(L_temp, add( shr(temp, 1), 15)); 1184 L_temp = L_shr(L_temp, 2); // To cope with 16-bit and 1185 excEnergy = extract_l(L_temp); // scaling in ex_ctrl() 1186 1187 if ( ((sub (mode, MR475) == 0) || 1188 (sub (mode, MR515) == 0) || 1189 (sub (mode, MR59) == 0)) && 1190 sub(st->voicedHangover, 5) > 0 && 1191 st->inBackgroundNoise != 0 && 1192 sub(st->state, 4) < 0 && 1193 ( (pdfi != 0 && st->prev_pdf != 0) || 1194 bfi != 0 || 1195 st->prev_bf != 0) ) 1196 { 1197 carefulFlag = 0; 1198 if ( pdfi != 0 && bfi == 0 ) 1199 { 1200 carefulFlag = 1; 1201 } 1202 1203 Ex_ctrl(exc_enhanced, 1204 excEnergy, 1205 st->excEnergyHist, 1206 st->voicedHangover, 1207 st->prev_bf, 1208 carefulFlag); 1209 } 1210 1211 if ( st->inBackgroundNoise != 0 && 1212 ( bfi != 0 || st->prev_bf != 0 ) && 1213 sub(st->state, 4) < 0 ) 1214 { 1215 ; // do nothing! 1216 } 1217 else 1218 { 1219 // Update energy history for all modes 1220 for (i = 0; i < 8; i++) 1221 { 1222 st->excEnergyHist[i] = st->excEnergyHist[i+1]; 1223 } 1224 st->excEnergyHist[8] = excEnergy; 1225 } 1226 *-------------------------------------------------------* 1227 * Excitation control module end. * 1228 *-------------------------------------------------------* 1229 1230 if (sub (pit_sharp, 16384) > 0) 1231 { 1232 for (i = 0; i < L_SUBFR; i++) 1233 { 1234 excp[i] = add (excp[i], exc_enhanced[i]); 1235 } 1236 agc2 (exc_enhanced, excp, L_SUBFR); 1237 Overflow = 0; 1238 Syn_filt (Az, excp, &synth[i_subfr], L_SUBFR, 1239 st->mem_syn, 0); 1240 } 1241 else 1242 { 1243 Overflow = 0; 1244 Syn_filt (Az, exc_enhanced, &synth[i_subfr], L_SUBFR, 1245 st->mem_syn, 0); 1246 } 1247 1248 if (Overflow != 0) // Test for overflow 1249 { 1250 for (i = 0; i < PIT_MAX + L_INTERPOL + L_SUBFR; i++) 1251 { 1252 st->old_exc[i] = shr(st->old_exc[i], 2); 1253 } 1254 for (i = 0; i < L_SUBFR; i++) 1255 { 1256 exc_enhanced[i] = shr(exc_enhanced[i], 2); 1257 } 1258 Syn_filt(Az, exc_enhanced, &synth[i_subfr], L_SUBFR, st->mem_syn, 1); 1259 } 1260 else 1261 { 1262 Copy(&synth[i_subfr+L_SUBFR-M], st->mem_syn, M); 1263 } 1264 1265 *--------------------------------------------------* 1266 * Update signal for next frame. * 1267 * -> shift to the left by L_SUBFR st->exc[] * 1268 *--------------------------------------------------* 1269 1270 Copy (&st->old_exc[L_SUBFR], &st->old_exc[0], PIT_MAX + L_INTERPOL); 1271 1272 // interpolated LPC parameters for next subframe 1273 Az += MP1; 1274 1275 // store T0 for next subframe 1276 st->old_T0 = T0; 1277 } 1278 1279 *-------------------------------------------------------* 1280 * Call the Source Characteristic Detector which updates * 1281 * st->inBackgroundNoise and st->voicedHangover. * 1282 *-------------------------------------------------------* 1283 1284 st->inBackgroundNoise = Bgn_scd(st->background_state, 1285 &(st->ltpGainHistory[0]), 1286 &(synth[0]), 1287 &(st->voicedHangover) ); 1288 1289 dtx_dec_activity_update(st->dtxDecoderState, 1290 st->lsfState->past_lsf_q, 1291 synth); 1292 1293 // store bfi for next subframe 1294 st->prev_bf = bfi; 1295 st->prev_pdf = pdfi; 1296 1297 *--------------------------------------------------* 1298 * Calculate the LSF averages on the eight * 1299 * previous frames * 1300 *--------------------------------------------------* 1301 1302 lsp_avg(st->lsp_avg_st, st->lsfState->past_lsf_q); 1303 1304the_end: 1305 st->dtxDecoderState->dtxGlobalState = newDTXState; 1306 1307 return 0; 1308} 1309 1310------------------------------------------------------------------------------ 1311 RESOURCES USED [optional] 1312 1313 When the code is written for a specific target processor the 1314 the resources used should be documented below. 1315 1316 HEAP MEMORY USED: x bytes 1317 1318 STACK MEMORY USED: x bytes 1319 1320 CLOCK CYCLES: (cycle count equation for this function) + (variable 1321 used to represent cycle count for each subroutine 1322 called) 1323 where: (cycle count variable) = cycle count for [subroutine 1324 name] 1325 1326------------------------------------------------------------------------------ 1327 CAUTION [optional] 1328 [State any special notes, constraints or cautions for users of this function] 1329 1330------------------------------------------------------------------------------ 1331*/ 1332 1333void Decoder_amr( 1334 Decoder_amrState *st, /* i/o : State variables */ 1335 enum Mode mode, /* i : AMR mode */ 1336 Word16 parm[], /* i : vector of synthesis parameters 1337 (PRM_SIZE) */ 1338 enum RXFrameType frame_type, /* i : received frame type */ 1339 Word16 synth[], /* o : synthesis speech (L_FRAME) */ 1340 Word16 A_t[] /* o : decoded LP filter in 4 subframes 1341 (AZ_SIZE) */ 1342) 1343{ 1344 /* LPC coefficients */ 1345 1346 Word16 *Az; /* Pointer on A_t */ 1347 1348 /* LSPs */ 1349 1350 Word16 lsp_new[M]; 1351 Word16 lsp_mid[M]; 1352 1353 /* LSFs */ 1354 1355 Word16 prev_lsf[M]; 1356 Word16 lsf_i[M]; 1357 1358 /* Algebraic codevector */ 1359 1360 Word16 code[L_SUBFR]; 1361 1362 /* excitation */ 1363 1364 Word16 excp[L_SUBFR]; 1365 Word16 exc_enhanced[L_SUBFR]; 1366 1367 /* Scalars */ 1368 1369 Word16 i; 1370 Word16 i_subfr; 1371 Word16 T0; 1372 Word16 T0_frac; 1373 Word16 index; 1374 Word16 index_mr475 = 0; 1375 Word16 gain_pit; 1376 Word16 gain_code; 1377 Word16 gain_code_mix; 1378 Word16 pit_sharp; 1379 Word16 pit_flag; 1380 Word16 pitch_fac; 1381 Word16 t0_min; 1382 Word16 t0_max; 1383 Word16 delta_frc_low; 1384 Word16 delta_frc_range; 1385 Word16 tmp_shift; 1386 Word16 temp; 1387 Word32 L_temp; 1388 Word16 flag4; 1389 Word16 carefulFlag; 1390 Word16 excEnergy; 1391 Word16 subfrNr; 1392 Word16 evenSubfr = 0; 1393 1394 Word16 bfi = 0; /* bad frame indication flag */ 1395 Word16 pdfi = 0; /* potential degraded bad frame flag */ 1396 1397 enum DTXStateType newDTXState; /* SPEECH , DTX, DTX_MUTE */ 1398 Flag *pOverflow = &(st->overflow); /* Overflow flag */ 1399 1400 1401 /* find the new DTX state SPEECH OR DTX */ 1402 newDTXState = rx_dtx_handler(&(st->dtxDecoderState), frame_type, pOverflow); 1403 1404 /* DTX actions */ 1405 1406 if (newDTXState != SPEECH) 1407 { 1408 Decoder_amr_reset(st, MRDTX); 1409 1410 dtx_dec(&(st->dtxDecoderState), 1411 st->mem_syn, 1412 &(st->lsfState), 1413 &(st->pred_state), 1414 &(st->Cb_gain_averState), 1415 newDTXState, 1416 mode, 1417 parm, synth, A_t, pOverflow); 1418 1419 /* update average lsp */ 1420 Lsf_lsp( 1421 st->lsfState.past_lsf_q, 1422 st->lsp_old, 1423 M, 1424 pOverflow); 1425 1426 lsp_avg( 1427 &(st->lsp_avg_st), 1428 st->lsfState.past_lsf_q, 1429 pOverflow); 1430 1431 goto the_end; 1432 } 1433 1434 /* SPEECH action state machine */ 1435 if ((frame_type == RX_SPEECH_BAD) || (frame_type == RX_NO_DATA) || 1436 (frame_type == RX_ONSET)) 1437 { 1438 bfi = 1; 1439 1440 if ((frame_type == RX_NO_DATA) || (frame_type == RX_ONSET)) 1441 { 1442 build_CN_param(&st->nodataSeed, 1443 prmno[mode], 1444 bitno[mode], 1445 parm, 1446 pOverflow); 1447 } 1448 } 1449 else if (frame_type == RX_SPEECH_DEGRADED) 1450 { 1451 pdfi = 1; 1452 } 1453 1454 if (bfi != 0) 1455 { 1456 st->state += 1; 1457 } 1458 else if (st->state == 6) 1459 1460 { 1461 st->state = 5; 1462 } 1463 else 1464 { 1465 st->state = 0; 1466 } 1467 1468 1469 if (st->state > 6) 1470 { 1471 st->state = 6; 1472 } 1473 1474 /* If this frame is the first speech frame after CNI period, */ 1475 /* set the BFH state machine to an appropriate state depending */ 1476 /* on whether there was DTX muting before start of speech or not */ 1477 /* If there was DTX muting, the first speech frame is muted. */ 1478 /* If there was no DTX muting, the first speech frame is not */ 1479 /* muted. The BFH state machine starts from state 5, however, to */ 1480 /* keep the audible noise resulting from a SID frame which is */ 1481 /* erroneously interpreted as a good speech frame as small as */ 1482 /* possible (the decoder output in this case is quickly muted) */ 1483 1484 if (st->dtxDecoderState.dtxGlobalState == DTX) 1485 { 1486 st->state = 5; 1487 st->prev_bf = 0; 1488 } 1489 else if (st->dtxDecoderState.dtxGlobalState == DTX_MUTE) 1490 { 1491 st->state = 5; 1492 st->prev_bf = 1; 1493 } 1494 1495 /* save old LSFs for CB gain smoothing */ 1496 Copy(st->lsfState.past_lsf_q, prev_lsf, M); 1497 1498 /* decode LSF parameters and generate interpolated lpc coefficients 1499 for the 4 subframes */ 1500 1501 if (mode != MR122) 1502 { 1503 D_plsf_3( 1504 &(st->lsfState), 1505 mode, 1506 bfi, 1507 parm, 1508 lsp_new, 1509 pOverflow); 1510 1511 /* Advance synthesis parameters pointer */ 1512 parm += 3; 1513 1514 Int_lpc_1to3( 1515 st->lsp_old, 1516 lsp_new, 1517 A_t, 1518 pOverflow); 1519 } 1520 else 1521 { 1522 D_plsf_5( 1523 &(st->lsfState), 1524 bfi, 1525 parm, 1526 lsp_mid, 1527 lsp_new, 1528 pOverflow); 1529 1530 /* Advance synthesis parameters pointer */ 1531 parm += 5; 1532 1533 Int_lpc_1and3( 1534 st->lsp_old, 1535 lsp_mid, 1536 lsp_new, 1537 A_t, 1538 pOverflow); 1539 } 1540 1541 /* update the LSPs for the next frame */ 1542 for (i = 0; i < M; i++) 1543 { 1544 st->lsp_old[i] = lsp_new[i]; 1545 } 1546 1547 /*------------------------------------------------------------------------* 1548 * Loop for every subframe in the analysis frame * 1549 *------------------------------------------------------------------------* 1550 * The subframe size is L_SUBFR and the loop is repeated L_FRAME/L_SUBFR * 1551 * times * 1552 * - decode the pitch delay * 1553 * - decode algebraic code * 1554 * - decode pitch and codebook gains * 1555 * - find the excitation and compute synthesis speech * 1556 *------------------------------------------------------------------------*/ 1557 1558 /* pointer to interpolated LPC parameters */ 1559 Az = A_t; 1560 1561 evenSubfr = 0; 1562 subfrNr = -1; 1563 for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR) 1564 { 1565 subfrNr += 1; 1566 evenSubfr = 1 - evenSubfr; 1567 1568 /* flag for first and 3th subframe */ 1569 pit_flag = i_subfr; 1570 1571 1572 if (i_subfr == L_FRAME_BY2) 1573 { 1574 if ((mode != MR475) && (mode != MR515)) 1575 { 1576 pit_flag = 0; 1577 } 1578 } 1579 1580 /* pitch index */ 1581 index = *parm++; 1582 1583 /*-------------------------------------------------------* 1584 * - decode pitch lag and find adaptive codebook vector. * 1585 *-------------------------------------------------------*/ 1586 1587 if (mode != MR122) 1588 { 1589 /* flag4 indicates encoding with 4 bit resolution; */ 1590 /* this is needed for mode MR475, MR515, MR59 and MR67 */ 1591 1592 flag4 = 0; 1593 1594 if ((mode == MR475) || (mode == MR515) || (mode == MR59) || 1595 (mode == MR67)) 1596 { 1597 flag4 = 1; 1598 } 1599 1600 /*-------------------------------------------------------* 1601 * - get ranges for the t0_min and t0_max * 1602 * - only needed in delta decoding * 1603 *-------------------------------------------------------*/ 1604 1605 delta_frc_low = 5; 1606 delta_frc_range = 9; 1607 1608 if (mode == MR795) 1609 { 1610 delta_frc_low = 10; 1611 delta_frc_range = 19; 1612 } 1613 1614 t0_min = sub(st->old_T0, delta_frc_low, pOverflow); 1615 1616 if (t0_min < PIT_MIN) 1617 { 1618 t0_min = PIT_MIN; 1619 } 1620 t0_max = add(t0_min, delta_frc_range, pOverflow); 1621 1622 if (t0_max > PIT_MAX) 1623 { 1624 t0_max = PIT_MAX; 1625 t0_min = t0_max - delta_frc_range; 1626 } 1627 1628 Dec_lag3(index, t0_min, t0_max, pit_flag, st->old_T0, 1629 &T0, &T0_frac, flag4, pOverflow); 1630 1631 st->T0_lagBuff = T0; 1632 1633 if (bfi != 0) 1634 { 1635 if (st->old_T0 < PIT_MAX) 1636 { /* Graceful pitch */ 1637 st->old_T0 += 0; /* degradation */ 1638 } 1639 T0 = st->old_T0; 1640 T0_frac = 0; 1641 1642 if ((st->inBackgroundNoise != 0) && (st->voicedHangover > 4) && 1643 ((mode == MR475) || (mode == MR515) || (mode == MR59))) 1644 { 1645 T0 = st->T0_lagBuff; 1646 } 1647 } 1648 1649 Pred_lt_3or6(st->exc, T0, T0_frac, L_SUBFR, 1, pOverflow); 1650 } 1651 else 1652 { 1653 Dec_lag6(index, PIT_MIN_MR122, 1654 PIT_MAX, pit_flag, &T0, &T0_frac, pOverflow); 1655 1656 1657 if (!(bfi == 0 && (pit_flag == 0 || index < 61))) 1658 { 1659 st->T0_lagBuff = T0; 1660 T0 = st->old_T0; 1661 T0_frac = 0; 1662 } 1663 1664 Pred_lt_3or6(st->exc, T0, T0_frac, L_SUBFR, 0, pOverflow); 1665 } 1666 1667 /*-------------------------------------------------------* 1668 * - (MR122 only: Decode pitch gain.) * 1669 * - Decode innovative codebook. * 1670 * - set pitch sharpening factor * 1671 *-------------------------------------------------------*/ 1672 if ((mode == MR475) || (mode == MR515)) 1673 { /* MR475, MR515 */ 1674 index = *parm++; /* index of position */ 1675 i = *parm++; /* signs */ 1676 1677 decode_2i40_9bits(subfrNr, i, index, code, pOverflow); 1678 1679 L_temp = (Word32)st->sharp << 1; 1680 if (L_temp != (Word32)((Word16) L_temp)) 1681 { 1682 pit_sharp = (st->sharp > 0) ? MAX_16 : MIN_16; 1683 } 1684 else 1685 { 1686 pit_sharp = (Word16) L_temp; 1687 } 1688 } 1689 else if (mode == MR59) 1690 { /* MR59 */ 1691 index = *parm++; /* index of position */ 1692 i = *parm++; /* signs */ 1693 1694 decode_2i40_11bits(i, index, code); 1695 1696 L_temp = (Word32)st->sharp << 1; 1697 if (L_temp != (Word32)((Word16) L_temp)) 1698 { 1699 pit_sharp = (st->sharp > 0) ? MAX_16 : MIN_16; 1700 } 1701 else 1702 { 1703 pit_sharp = (Word16) L_temp; 1704 } 1705 } 1706 else if (mode == MR67) 1707 { /* MR67 */ 1708 index = *parm++; /* index of position */ 1709 i = *parm++; /* signs */ 1710 1711 decode_3i40_14bits(i, index, code); 1712 1713 L_temp = (Word32)st->sharp << 1; 1714 if (L_temp != (Word32)((Word16) L_temp)) 1715 { 1716 pit_sharp = (st->sharp > 0) ? MAX_16 : MIN_16; 1717 } 1718 else 1719 { 1720 pit_sharp = (Word16) L_temp; 1721 } 1722 } 1723 else if (mode <= MR795) 1724 { /* MR74, MR795 */ 1725 index = *parm++; /* index of position */ 1726 i = *parm++; /* signs */ 1727 1728 decode_4i40_17bits(i, index, code); 1729 1730 L_temp = (Word32)st->sharp << 1; 1731 if (L_temp != (Word32)((Word16) L_temp)) 1732 { 1733 pit_sharp = (st->sharp > 0) ? MAX_16 : MIN_16; 1734 } 1735 else 1736 { 1737 pit_sharp = (Word16) L_temp; 1738 } 1739 } 1740 else if (mode == MR102) 1741 { /* MR102 */ 1742 dec_8i40_31bits(parm, code, pOverflow); 1743 parm += 7; 1744 1745 L_temp = (Word32)st->sharp << 1; 1746 if (L_temp != (Word32)((Word16) L_temp)) 1747 { 1748 pit_sharp = (st->sharp > 0) ? MAX_16 : MIN_16; 1749 } 1750 else 1751 { 1752 pit_sharp = (Word16) L_temp; 1753 } 1754 } 1755 else 1756 { /* MR122 */ 1757 index = *parm++; 1758 1759 if (bfi != 0) 1760 { 1761 ec_gain_pitch( 1762 &(st->ec_gain_p_st), 1763 st->state, 1764 &gain_pit, 1765 pOverflow); 1766 } 1767 else 1768 { 1769 gain_pit = d_gain_pitch(mode, index); 1770 } 1771 ec_gain_pitch_update( 1772 &(st->ec_gain_p_st), 1773 bfi, 1774 st->prev_bf, 1775 &gain_pit, 1776 pOverflow); 1777 1778 1779 dec_10i40_35bits(parm, code); 1780 parm += 10; 1781 1782 /* pit_sharp = gain_pit; */ 1783 /* if (pit_sharp > 1.0) pit_sharp = 1.0; */ 1784 1785 L_temp = (Word32)gain_pit << 1; 1786 if (L_temp != (Word32)((Word16) L_temp)) 1787 { 1788 pit_sharp = (gain_pit > 0) ? MAX_16 : MIN_16; 1789 } 1790 else 1791 { 1792 pit_sharp = (Word16) L_temp; 1793 } 1794 } 1795 /*-------------------------------------------------------* 1796 * - Add the pitch contribution to code[]. * 1797 *-------------------------------------------------------*/ 1798 for (i = T0; i < L_SUBFR; i++) 1799 { 1800 temp = mult(*(code + i - T0), pit_sharp, pOverflow); 1801 *(code + i) = add(*(code + i), temp, pOverflow); 1802 1803 } 1804 1805 /*------------------------------------------------------------* 1806 * - Decode codebook gain (MR122) or both pitch * 1807 * gain and codebook gain (all others) * 1808 * - Update pitch sharpening "sharp" with quantized gain_pit * 1809 *------------------------------------------------------------*/ 1810 if (mode == MR475) 1811 { 1812 /* read and decode pitch and code gain */ 1813 1814 if (evenSubfr != 0) 1815 { 1816 index_mr475 = *parm++; /* index of gain(s) */ 1817 } 1818 1819 if (bfi == 0) 1820 { 1821 Dec_gain( 1822 &(st->pred_state), 1823 mode, 1824 index_mr475, 1825 code, 1826 evenSubfr, 1827 &gain_pit, 1828 &gain_code, 1829 pOverflow); 1830 } 1831 else 1832 { 1833 ec_gain_pitch( 1834 &(st->ec_gain_p_st), 1835 st->state, 1836 &gain_pit, 1837 pOverflow); 1838 1839 ec_gain_code( 1840 &(st->ec_gain_c_st), 1841 &(st->pred_state), 1842 st->state, 1843 &gain_code, 1844 pOverflow); 1845 } 1846 ec_gain_pitch_update( 1847 &st->ec_gain_p_st, 1848 bfi, 1849 st->prev_bf, 1850 &gain_pit, 1851 pOverflow); 1852 1853 ec_gain_code_update( 1854 &st->ec_gain_c_st, 1855 bfi, 1856 st->prev_bf, 1857 &gain_code, 1858 pOverflow); 1859 1860 pit_sharp = gain_pit; 1861 1862 if (pit_sharp > SHARPMAX) 1863 { 1864 pit_sharp = SHARPMAX; 1865 } 1866 1867 } 1868 else if ((mode <= MR74) || (mode == MR102)) 1869 { 1870 /* read and decode pitch and code gain */ 1871 index = *parm++; /* index of gain(s) */ 1872 1873 if (bfi == 0) 1874 { 1875 Dec_gain( 1876 &(st->pred_state), 1877 mode, 1878 index, 1879 code, 1880 evenSubfr, 1881 &gain_pit, 1882 &gain_code, 1883 pOverflow); 1884 } 1885 else 1886 { 1887 ec_gain_pitch( 1888 &(st->ec_gain_p_st), 1889 st->state, 1890 &gain_pit, 1891 pOverflow); 1892 1893 ec_gain_code( 1894 &(st->ec_gain_c_st), 1895 &(st->pred_state), 1896 st->state, 1897 &gain_code, 1898 pOverflow); 1899 } 1900 1901 ec_gain_pitch_update( 1902 &(st->ec_gain_p_st), 1903 bfi, 1904 st->prev_bf, 1905 &gain_pit, 1906 pOverflow); 1907 1908 ec_gain_code_update( 1909 &(st->ec_gain_c_st), 1910 bfi, 1911 st->prev_bf, 1912 &gain_code, 1913 pOverflow); 1914 1915 pit_sharp = gain_pit; 1916 1917 if (pit_sharp > SHARPMAX) 1918 { 1919 pit_sharp = SHARPMAX; 1920 } 1921 1922 if (mode == MR102) 1923 { 1924 if (st->old_T0 > (L_SUBFR + 5)) 1925 { 1926 if (pit_sharp < 0) 1927 { 1928 pit_sharp = ~((~pit_sharp) >> 2); 1929 } 1930 else 1931 { 1932 pit_sharp = pit_sharp >> 2; 1933 } 1934 } 1935 } 1936 } 1937 else 1938 { 1939 /* read and decode pitch gain */ 1940 index = *parm++; /* index of gain(s) */ 1941 1942 if (mode == MR795) 1943 { 1944 /* decode pitch gain */ 1945 if (bfi != 0) 1946 { 1947 ec_gain_pitch( 1948 &(st->ec_gain_p_st), 1949 st->state, 1950 &gain_pit, 1951 pOverflow); 1952 } 1953 else 1954 { 1955 gain_pit = d_gain_pitch(mode, index); 1956 } 1957 ec_gain_pitch_update( 1958 &(st->ec_gain_p_st), 1959 bfi, 1960 st->prev_bf, 1961 &gain_pit, 1962 pOverflow); 1963 1964 /* read and decode code gain */ 1965 index = *parm++; 1966 1967 if (bfi == 0) 1968 { 1969 d_gain_code( 1970 &(st->pred_state), 1971 mode, 1972 index, 1973 code, 1974 &gain_code, 1975 pOverflow); 1976 } 1977 else 1978 { 1979 ec_gain_code( 1980 &(st->ec_gain_c_st), 1981 &(st->pred_state), 1982 st->state, 1983 &gain_code, 1984 pOverflow); 1985 } 1986 1987 ec_gain_code_update( 1988 &(st->ec_gain_c_st), 1989 bfi, 1990 st->prev_bf, 1991 &gain_code, 1992 pOverflow); 1993 1994 pit_sharp = gain_pit; 1995 1996 if (pit_sharp > SHARPMAX) 1997 { 1998 pit_sharp = SHARPMAX; 1999 } 2000 } 2001 else 2002 { /* MR122 */ 2003 2004 if (bfi == 0) 2005 { 2006 d_gain_code( 2007 &(st->pred_state), 2008 mode, 2009 index, 2010 code, 2011 &gain_code, 2012 pOverflow); 2013 } 2014 else 2015 { 2016 ec_gain_code( 2017 &(st->ec_gain_c_st), 2018 &(st->pred_state), 2019 st->state, 2020 &gain_code, 2021 pOverflow); 2022 } 2023 2024 ec_gain_code_update( 2025 &(st->ec_gain_c_st), 2026 bfi, 2027 st->prev_bf, 2028 &gain_code, 2029 pOverflow); 2030 2031 pit_sharp = gain_pit; 2032 } 2033 } 2034 2035 /* store pitch sharpening for next subframe */ 2036 /* (for modes which use the previous pitch gain for */ 2037 /* pitch sharpening in the search phase) */ 2038 /* do not update sharpening in even subframes for MR475 */ 2039 if ((mode != MR475) || (evenSubfr == 0)) 2040 { 2041 st->sharp = gain_pit; 2042 2043 if (st->sharp > SHARPMAX) 2044 { 2045 st->sharp = SHARPMAX; 2046 } 2047 } 2048 2049 pit_sharp = shl(pit_sharp, 1, pOverflow); 2050 2051 if (pit_sharp > 16384) 2052 { 2053 for (i = 0; i < L_SUBFR; i++) 2054 { 2055 temp = mult(st->exc[i], pit_sharp, pOverflow); 2056 L_temp = L_mult(temp, gain_pit, pOverflow); 2057 2058 if (mode == MR122) 2059 { 2060 if (L_temp < 0) 2061 { 2062 L_temp = ~((~L_temp) >> 1); 2063 } 2064 else 2065 { 2066 L_temp = L_temp >> 1; 2067 } 2068 } 2069 *(excp + i) = pv_round(L_temp, pOverflow); 2070 } 2071 } 2072 2073 /*-------------------------------------------------------* 2074 * - Store list of LTP gains needed in the source * 2075 * characteristic detector (SCD) * 2076 *-------------------------------------------------------*/ 2077 2078 if (bfi == 0) 2079 { 2080 for (i = 0; i < 8; i++) 2081 { 2082 st->ltpGainHistory[i] = st->ltpGainHistory[i+1]; 2083 } 2084 st->ltpGainHistory[8] = gain_pit; 2085 } 2086 2087 /*-------------------------------------------------------* 2088 * - Limit gain_pit if in background noise and BFI * 2089 * for MR475, MR515, MR59 * 2090 *-------------------------------------------------------*/ 2091 2092 2093 if ((st->prev_bf != 0 || bfi != 0) && st->inBackgroundNoise != 0 && 2094 ((mode == MR475) || (mode == MR515) || (mode == MR59))) 2095 { 2096 2097 if (gain_pit > 12288) /* if (gain_pit > 0.75) in Q14*/ 2098 { 2099 gain_pit = ((gain_pit - 12288) >> 1) + 12288; 2100 /* gain_pit = (gain_pit-0.75)/2.0 + 0.75; */ 2101 } 2102 2103 if (gain_pit > 14745) /* if (gain_pit > 0.90) in Q14*/ 2104 { 2105 gain_pit = 14745; 2106 } 2107 } 2108 2109 /*-------------------------------------------------------* 2110 * Calculate CB mixed gain * 2111 *-------------------------------------------------------*/ 2112 Int_lsf( 2113 prev_lsf, 2114 st->lsfState.past_lsf_q, 2115 i_subfr, 2116 lsf_i, 2117 pOverflow); 2118 2119 gain_code_mix = 2120 Cb_gain_average( 2121 &(st->Cb_gain_averState), 2122 mode, 2123 gain_code, 2124 lsf_i, 2125 st->lsp_avg_st.lsp_meanSave, 2126 bfi, 2127 st->prev_bf, 2128 pdfi, 2129 st->prev_pdf, 2130 st->inBackgroundNoise, 2131 st->voicedHangover, 2132 pOverflow); 2133 2134 /* make sure that MR74, MR795, MR122 have original code_gain*/ 2135 if ((mode > MR67) && (mode != MR102)) 2136 /* MR74, MR795, MR122 */ 2137 { 2138 gain_code_mix = gain_code; 2139 } 2140 2141 /*-------------------------------------------------------* 2142 * - Find the total excitation. * 2143 * - Find synthesis speech corresponding to st->exc[]. * 2144 *-------------------------------------------------------*/ 2145 if (mode <= MR102) /* MR475, MR515, MR59, MR67, MR74, MR795, MR102*/ 2146 { 2147 pitch_fac = gain_pit; 2148 tmp_shift = 1; 2149 } 2150 else /* MR122 */ 2151 { 2152 if (gain_pit < 0) 2153 { 2154 pitch_fac = ~((~gain_pit) >> 1); 2155 } 2156 else 2157 { 2158 pitch_fac = gain_pit >> 1; 2159 } 2160 tmp_shift = 2; 2161 } 2162 2163 /* copy unscaled LTP excitation to exc_enhanced (used in phase 2164 * dispersion below) and compute total excitation for LTP feedback 2165 */ 2166 for (i = 0; i < L_SUBFR; i++) 2167 { 2168 exc_enhanced[i] = st->exc[i]; 2169 2170 /* st->exc[i] = gain_pit*st->exc[i] + gain_code*code[i]; */ 2171 L_temp = L_mult(st->exc[i], pitch_fac, pOverflow); 2172 /* 12.2: Q0 * Q13 */ 2173 /* 7.4: Q0 * Q14 */ 2174 L_temp = L_mac(L_temp, code[i], gain_code, pOverflow); 2175 /* 12.2: Q12 * Q1 */ 2176 /* 7.4: Q13 * Q1 */ 2177 L_temp = L_shl(L_temp, tmp_shift, pOverflow); /* Q16 */ 2178 st->exc[i] = pv_round(L_temp, pOverflow); 2179 } 2180 2181 /*-------------------------------------------------------* 2182 * - Adaptive phase dispersion * 2183 *-------------------------------------------------------*/ 2184 ph_disp_release(&(st->ph_disp_st)); /* free phase dispersion adaption */ 2185 2186 2187 if (((mode == MR475) || (mode == MR515) || (mode == MR59)) && 2188 (st->voicedHangover > 3) && (st->inBackgroundNoise != 0) && 2189 (bfi != 0)) 2190 { 2191 ph_disp_lock(&(st->ph_disp_st)); /* Always Use full Phase Disp. */ 2192 } /* if error in bg noise */ 2193 2194 /* apply phase dispersion to innovation (if enabled) and 2195 compute total excitation for synthesis part */ 2196 ph_disp( 2197 &(st->ph_disp_st), 2198 mode, 2199 exc_enhanced, 2200 gain_code_mix, 2201 gain_pit, 2202 code, 2203 pitch_fac, 2204 tmp_shift, 2205 pOverflow); 2206 2207 /*-------------------------------------------------------* 2208 * - The Excitation control module are active during BFI.* 2209 * - Conceal drops in signal energy if in bg noise. * 2210 *-------------------------------------------------------*/ 2211 L_temp = 0; 2212 for (i = 0; i < L_SUBFR; i++) 2213 { 2214 L_temp = L_mac(L_temp, *(exc_enhanced + i), *(exc_enhanced + i), pOverflow); 2215 } 2216 2217 /* excEnergy = sqrt(L_temp) in Q0 */ 2218 if (L_temp < 0) 2219 { 2220 L_temp = ~((~L_temp) >> 1); 2221 } 2222 else 2223 { 2224 L_temp = L_temp >> 1; 2225 } 2226 2227 L_temp = sqrt_l_exp(L_temp, &temp, pOverflow); 2228 /* To cope with 16-bit and scaling in ex_ctrl() */ 2229 L_temp = L_shr(L_temp, (Word16)((temp >> 1) + 15), pOverflow); 2230 if (L_temp < 0) 2231 { 2232 excEnergy = (Word16)(~((~L_temp) >> 2)); 2233 } 2234 else 2235 { 2236 excEnergy = (Word16)(L_temp >> 2); 2237 } 2238 2239 if (((mode == MR475) || (mode == MR515) || (mode == MR59)) && 2240 (st->voicedHangover > 5) && (st->inBackgroundNoise != 0) && 2241 (st->state < 4) && 2242 ((pdfi != 0 && st->prev_pdf != 0) || bfi != 0 || st->prev_bf != 0)) 2243 { 2244 carefulFlag = 0; 2245 2246 if (pdfi != 0 && bfi == 0) 2247 { 2248 carefulFlag = 1; 2249 } 2250 2251 Ex_ctrl(exc_enhanced, 2252 excEnergy, 2253 st->excEnergyHist, 2254 st->voicedHangover, 2255 st->prev_bf, 2256 carefulFlag, pOverflow); 2257 } 2258 2259 if (!((st->inBackgroundNoise != 0) && (bfi != 0 || st->prev_bf != 0) && 2260 (st->state < 4))) 2261 { 2262 /* Update energy history for all modes */ 2263 for (i = 0; i < 8; i++) 2264 { 2265 st->excEnergyHist[i] = st->excEnergyHist[i+1]; 2266 } 2267 st->excEnergyHist[8] = excEnergy; 2268 } 2269 /*-------------------------------------------------------* 2270 * Excitation control module end. * 2271 *-------------------------------------------------------*/ 2272 if (pit_sharp > 16384) 2273 { 2274 for (i = 0; i < L_SUBFR; i++) 2275 { 2276 *(excp + i) = add(*(excp + i), *(exc_enhanced + i), pOverflow); 2277 2278 } 2279 agc2(exc_enhanced, excp, L_SUBFR, pOverflow); 2280 *pOverflow = 0; 2281 Syn_filt(Az, excp, &synth[i_subfr], L_SUBFR, 2282 st->mem_syn, 0); 2283 } 2284 else 2285 { 2286 *pOverflow = 0; 2287 Syn_filt(Az, exc_enhanced, &synth[i_subfr], L_SUBFR, 2288 st->mem_syn, 0); 2289 } 2290 2291 if (*pOverflow != 0) /* Test for overflow */ 2292 { 2293 for (i = PIT_MAX + L_INTERPOL + L_SUBFR - 1; i >= 0; i--) 2294 { 2295 if (st->old_exc[i] < 0) 2296 { 2297 st->old_exc[i] = ~((~st->old_exc[i]) >> 2); 2298 } 2299 else 2300 { 2301 st->old_exc[i] = st->old_exc[i] >> 2; 2302 } 2303 2304 } 2305 2306 for (i = L_SUBFR - 1; i >= 0; i--) 2307 { 2308 if (*(exc_enhanced + i) < 0) 2309 { 2310 *(exc_enhanced + i) = ~((~(*(exc_enhanced + i))) >> 2); 2311 } 2312 else 2313 { 2314 *(exc_enhanced + i) = *(exc_enhanced + i) >> 2; 2315 } 2316 } 2317 Syn_filt(Az, exc_enhanced, &synth[i_subfr], L_SUBFR, st->mem_syn, 1); 2318 } 2319 else 2320 { 2321 Copy(&synth[i_subfr+L_SUBFR-M], st->mem_syn, M); 2322 } 2323 2324 /*--------------------------------------------------* 2325 * Update signal for next frame. * 2326 * -> shift to the left by L_SUBFR st->exc[] * 2327 *--------------------------------------------------*/ 2328 2329 Copy(&st->old_exc[L_SUBFR], &st->old_exc[0], PIT_MAX + L_INTERPOL); 2330 2331 /* interpolated LPC parameters for next subframe */ 2332 Az += MP1; 2333 2334 /* store T0 for next subframe */ 2335 st->old_T0 = T0; 2336 } 2337 2338 /*-------------------------------------------------------* 2339 * Call the Source Characteristic Detector which updates * 2340 * st->inBackgroundNoise and st->voicedHangover. * 2341 *-------------------------------------------------------*/ 2342 2343 st->inBackgroundNoise = 2344 Bgn_scd( 2345 &(st->background_state), 2346 &(st->ltpGainHistory[0]), 2347 &(synth[0]), 2348 &(st->voicedHangover), 2349 pOverflow); 2350 2351 dtx_dec_activity_update( 2352 &(st->dtxDecoderState), 2353 st->lsfState.past_lsf_q, 2354 synth, 2355 pOverflow); 2356 2357 /* store bfi for next subframe */ 2358 st->prev_bf = bfi; 2359 st->prev_pdf = pdfi; 2360 2361 /*--------------------------------------------------* 2362 * Calculate the LSF averages on the eight * 2363 * previous frames * 2364 *--------------------------------------------------*/ 2365 lsp_avg( 2366 &(st->lsp_avg_st), 2367 st->lsfState.past_lsf_q, 2368 pOverflow); 2369 2370the_end: 2371 st->dtxDecoderState.dtxGlobalState = newDTXState; 2372 2373// return(0); 2374} 2375