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 33 34 Pathname: ./audio/gsm-amr/c/src/d_plsf_3.c 35 Functions: D_plsf_3 36 37 ------------------------------------------------------------------------------ 38 INPUT AND OUTPUT DEFINITIONS 39 40 Inputs: 41 st -- Pointer to type struct D_plsfState 42 mode -- enum Mode -- coder mode 43 bfi -- Word16 -- bad frame indicator (set to 1 if a bad frame is received) 44 indice -- Pointer to type Word16 -- quantization indices of 45 3 submatrices, Q0 46 47 Outputs: 48 st -- Pointer to type struct D_plsfState 49 lsp1_q -- Pointer to type Word16 -- quantized 1st LSP vector Q15 50 pOverflow -- Pointer to type Flag -- Flag set when overflow occurs 51 52 Returns: 53 None. 54 55 Global Variables Used: 56 None 57 58 Local Variables Needed: 59 None 60 61------------------------------------------------------------------------------ 62 FUNCTION DESCRIPTION 63 64 PURPOSE: Decodes the LSP parameters using the received quantization 65 indices.1st order MA prediction and split by 3 vector 66 quantization (split-VQ) 67 68------------------------------------------------------------------------------ 69 REQUIREMENTS 70 71 72 73------------------------------------------------------------------------------ 74 REFERENCES 75 76 d_plsf_3.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001 77 78------------------------------------------------------------------------------ 79 PSEUDO-CODE 80 81 82 83------------------------------------------------------------------------------ 84 RESOURCES USED 85 When the code is written for a specific target processor the 86 the resources used should be documented below. 87 88 STACK USAGE: [stack count for this module] + [variable to represent 89 stack usage for each subroutine called] 90 91 where: [stack usage variable] = stack usage for [subroutine 92 name] (see [filename].ext) 93 94 DATA MEMORY USED: x words 95 96 PROGRAM MEMORY USED: x words 97 98 CLOCK CYCLES: [cycle count equation for this module] + [variable 99 used to represent cycle count for each subroutine 100 called] 101 102 where: [cycle count variable] = cycle count for [subroutine 103 name] (see [filename].ext) 104 105------------------------------------------------------------------------------ 106*/ 107 108 109/*---------------------------------------------------------------------------- 110; INCLUDES 111----------------------------------------------------------------------------*/ 112#include "d_plsf.h" 113#include "typedef.h" 114#include "basic_op.h" 115#include "lsp_lsf.h" 116#include "reorder.h" 117#include "copy.h" 118#include "q_plsf_3_tbl.h" 119 120 121/*---------------------------------------------------------------------------- 122; MACROS 123; Define module specific macros here 124----------------------------------------------------------------------------*/ 125 126 127/*---------------------------------------------------------------------------- 128; DEFINES 129; Include all pre-processor statements here. Include conditional 130; compile variables also. 131----------------------------------------------------------------------------*/ 132#define ALPHA 29491 /* ALPHA -> 0.9 */ 133#define ONE_ALPHA 3277 /* ONE_ALPHA-> (1.0-ALPHA) */ 134 135 136/*---------------------------------------------------------------------------- 137; LOCAL FUNCTION DEFINITIONS 138; Function Prototype declaration 139----------------------------------------------------------------------------*/ 140 141 142/*---------------------------------------------------------------------------- 143; LOCAL STORE/BUFFER/POINTER DEFINITIONS 144; Variable declaration - defined here and used outside this module 145----------------------------------------------------------------------------*/ 146 147/*---------------------------------------------------------------------------- 148; EXTERNAL FUNCTION REFERENCES 149; Declare functions defined elsewhere and referenced in this module 150----------------------------------------------------------------------------*/ 151 152/*---------------------------------------------------------------------------- 153; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES 154; Declare variables used in this module but defined elsewhere 155----------------------------------------------------------------------------*/ 156 157 158/*---------------------------------------------------------------------------- 159; FUNCTION CODE 160----------------------------------------------------------------------------*/ 161 162void D_plsf_3( 163 D_plsfState *st, /* i/o: State struct */ 164 enum Mode mode, /* i : coder mode */ 165 Word16 bfi, /* i : bad frame indicator (set to 1 if a */ 166 /* bad frame is received) */ 167 Word16 * indice, /* i : quantization indices of 3 submatrices, Q0 */ 168 Word16 * lsp1_q, /* o : quantized 1st LSP vector, Q15 */ 169 Flag *pOverflow /* o : Flag set when overflow occurs */ 170) 171{ 172 Word16 i; 173 Word16 temp; 174 Word16 index; 175 176 Word16 lsf1_r[M]; 177 Word16 lsf1_q[M]; 178 179 if (bfi != 0) /* if bad frame */ 180 { 181 /* use the past LSFs slightly shifted towards their mean */ 182 183 for (i = 0; i < M; i++) 184 { 185 /* lsfi_q[i] = ALPHA*past_lsf_q[i] + ONE_ALPHA*mean_lsf[i]; */ 186 temp = 187 mult( 188 st->past_lsf_q[i], 189 ALPHA, 190 pOverflow); 191 192 index = 193 mult( 194 mean_lsf_3[i], 195 ONE_ALPHA, 196 pOverflow); 197 198 lsf1_q[i] = 199 add( 200 index, 201 temp, 202 pOverflow); 203 } 204 205 /* estimate past quantized residual to be used in next frame */ 206 if (mode != MRDTX) 207 { 208 for (i = 0; i < M; i++) 209 { 210 /* temp = mean_lsf[i] + past_r2_q[i] * PRED_FAC; */ 211 212 temp = 213 mult( 214 st->past_r_q[i], 215 pred_fac_3[i], 216 pOverflow); 217 218 temp = 219 add( 220 mean_lsf_3[i], 221 temp, 222 pOverflow); 223 224 st->past_r_q[i] = 225 sub( 226 lsf1_q[i], 227 temp, 228 pOverflow); 229 } 230 231 } /* if (mode == MRDTX) */ 232 else 233 { 234 for (i = 0; i < M; i++) 235 { 236 /* temp = mean_lsf[i] + past_r2_q[i]; */ 237 238 temp = 239 add( 240 mean_lsf_3[i], 241 st->past_r_q[i], 242 pOverflow); 243 244 st->past_r_q[i] = 245 sub( 246 lsf1_q[i], 247 temp, 248 pOverflow); 249 } 250 } 251 252 } /* if (bfi != 0) */ 253 254 else /* if good LSFs received */ 255 { 256 257 Word16 index_limit_1 = 0; 258 Word16 index_limit_2 = (DICO2_SIZE - 1) * 3; 259 Word16 index_limit_3 = 0; 260 261 const Word16 *p_cb1; 262 const Word16 *p_cb2; 263 const Word16 *p_cb3; 264 const Word16 *p_dico; 265 266 267 p_cb2 = dico2_lsf_3; /* size DICO2_SIZE*3 */ 268 269 if ((mode == MR475) || (mode == MR515)) 270 { /* MR475, MR515 */ 271 p_cb1 = dico1_lsf_3; /* size DICO1_SIZE*3 */ 272 p_cb3 = mr515_3_lsf; /* size MR515_3_SIZE*4 */ 273 274 index_limit_1 = (DICO1_SIZE - 1) * 3; 275 index_limit_3 = (MR515_3_SIZE - 1) * 4; 276 277 } 278 else if (mode == MR795) 279 { /* MR795 */ 280 p_cb1 = mr795_1_lsf; /* size MR795_1_SIZE*3 */ 281 p_cb3 = dico3_lsf_3; /* size DICO3_SIZE*4 */ 282 283 index_limit_1 = (MR795_1_SIZE - 1) * 3; 284 index_limit_3 = (DICO3_SIZE - 1) * 4; 285 286 } 287 else 288 { /* MR59, MR67, MR74, MR102, MRDTX */ 289 p_cb1 = dico1_lsf_3; /* size DICO1_SIZE*3 */ 290 p_cb3 = dico3_lsf_3; /* size DICO3_SIZE*4 */ 291 292 index_limit_1 = (DICO1_SIZE - 1) * 3; 293 index_limit_3 = (DICO3_SIZE - 1) * 4; 294 295 } 296 297 /* decode prediction residuals from 3 received indices */ 298 299 index = *indice++; 300 301 /* temp = 3*index; */ 302 temp = index + (index << 1); 303 304 if (temp > index_limit_1) 305 { 306 temp = index_limit_1; /* avoid buffer overrun */ 307 } 308 309 p_dico = &p_cb1[temp]; 310 311 lsf1_r[0] = *p_dico++; 312 lsf1_r[1] = *p_dico++; 313 lsf1_r[2] = *p_dico++; 314 315 index = *indice++; 316 317 if (mode == MR475 || mode == MR515) 318 { /* MR475, MR515 only using every second entry */ 319 index <<= 1; 320 } 321 322 /* temp = 3*index */ 323 temp = index + (index << 1); 324 325 if (temp > index_limit_2) 326 { 327 temp = index_limit_2; /* avoid buffer overrun */ 328 } 329 330 p_dico = &p_cb2[temp]; 331 332 lsf1_r[3] = *p_dico++; 333 lsf1_r[4] = *p_dico++; 334 lsf1_r[5] = *p_dico++; 335 336 index = *indice++; 337 338 temp = index << 2; 339 340 if (temp > index_limit_3) 341 { 342 temp = index_limit_3; /* avoid buffer overrun */ 343 } 344 345 346 p_dico = &p_cb3[temp]; 347 348 lsf1_r[6] = *p_dico++; 349 lsf1_r[7] = *p_dico++; 350 lsf1_r[8] = *p_dico++; 351 lsf1_r[9] = *p_dico++; 352 353 /* Compute quantized LSFs and update the past quantized residual */ 354 355 if (mode != MRDTX) 356 { 357 for (i = 0; i < M; i++) 358 { 359 temp = 360 mult( 361 st->past_r_q[i], 362 pred_fac_3[i], 363 pOverflow); 364 365 temp = 366 add( 367 mean_lsf_3[i], 368 temp, 369 pOverflow); 370 371 lsf1_q[i] = 372 add( 373 lsf1_r[i], 374 temp, 375 pOverflow); 376 377 st->past_r_q[i] = lsf1_r[i]; 378 } 379 } 380 else 381 { 382 for (i = 0; i < M; i++) 383 { 384 temp = 385 add( 386 mean_lsf_3[i], 387 st->past_r_q[i], 388 pOverflow); 389 390 lsf1_q[i] = 391 add( 392 lsf1_r[i], 393 temp, 394 pOverflow); 395 396 st->past_r_q[i] = lsf1_r[i]; 397 } 398 } 399 400 } 401 402 /* verification that LSFs has minimum distance of LSF_GAP Hz */ 403 404 Reorder_lsf( 405 lsf1_q, 406 LSF_GAP, 407 M, 408 pOverflow); 409 410 Copy( 411 lsf1_q, 412 st->past_lsf_q, 413 M); 414 415 /* convert LSFs to the cosine domain */ 416 417 Lsf_lsp( 418 lsf1_q, 419 lsp1_q, 420 M, 421 pOverflow); 422 423 return; 424} 425 426/* 427------------------------------------------------------------------------------ 428 FUNCTION NAME: Init_D_plsf_3 429------------------------------------------------------------------------------ 430 INPUT AND OUTPUT DEFINITIONS 431 432 Inputs: 433 st = pointer to a structure of type D_plsfState 434 index = Word16, past_rq_init[] index [0, 7] 435 436 Outputs: 437 st = pointer to a structure of type D_plsfState 438 439 Returns: 440 None 441 442 Global Variables Used: 443 None. 444 445 Local Variables Needed: 446 None. 447 448------------------------------------------------------------------------------ 449 FUNCTION DESCRIPTION 450 451 This function initializes the D_plsfState structure. 452 453------------------------------------------------------------------------------ 454 REQUIREMENTS 455 456 None. 457 458------------------------------------------------------------------------------ 459 REFERENCES 460 461 d_plsf_3.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001 462 463------------------------------------------------------------------------------ 464 PSEUDO-CODE 465 466------------------------------------------------------------------------------ 467 RESOURCES USED [optional] 468 469 When the code is written for a specific target processor the 470 the resources used should be documented below. 471 472 HEAP MEMORY USED: x bytes 473 474 STACK MEMORY USED: x bytes 475 476 CLOCK CYCLES: (cycle count equation for this function) + (variable 477 used to represent cycle count for each subroutine 478 called) 479 where: (cycle count variable) = cycle count for [subroutine 480 name] 481 482------------------------------------------------------------------------------ 483 CAUTION [optional] 484 [State any special notes, constraints or cautions for users of this function] 485 486------------------------------------------------------------------------------ 487*/ 488void Init_D_plsf_3( 489 D_plsfState *st, /* i/o: State struct */ 490 Word16 index /* i : past_rq_init[] index [0, 7] */) 491{ 492 Copy( 493 &past_rq_init[index * M], 494 st->past_r_q, 495 M); 496} 497