/* ------------------------------------------------------------------ * Copyright (C) 1998-2009 PacketVideo * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. * See the License for the specific language governing permissions * and limitations under the License. * ------------------------------------------------------------------- */ /**************************************************************************************** Portions of this file are derived from the following 3GPP standard: 3GPP TS 26.073 ANSI-C code for the Adaptive Multi-Rate (AMR) speech codec Available from http://www.3gpp.org (C) 2004, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TTA, TTC) Permission to distribute, modify and use this file under the standard license terms listed above has been obtained from the copyright holder. ****************************************************************************************/ /* Pathname: ./audio/gsm-amr/c/src/lsp_az.c Funtions: Get_lsp_pol Lsp_Az ------------------------------------------------------------------------------ REVISION HISTORY Description: Updated template used to PV coding template. First attempt at optimizing C code. Description: Deleted all Local stores needed/modified. Optimized Lsp_Az function by getting rid of call to L_shr_r function. Description: Updated file per comments gathered from Phase 2/3 review. Description: Added setting of Overflow flag in the inlined code. Description: 1. Optimized Lsp_Az function code. 2. Changed Input/Output definitions by adding Word type. Description: Made changes based on review meeting. 1. Removed pseudocode. Description: Synchronized file with UMTS version 3.2.0. Updated coding template. Removed unnecessary include files. Description: Replaced basic_op.h and oper_32b.h with the header files of the math functions used in the file. Description: Modified to pass overflow flag through to L_add and L_sub. The flag is passed back to the calling function by pointer reference. Description: Removed the id line since it was removed in the header file by Ken. Description: Added the write-only variable, pOverflow, to the inputs section. Description: For lsp_az() and Get_lsp_pol() 1. Eliminated unused include files. 2. Replaced array addressing by pointers 3. Eliminated math operations that unnecessary checked for saturation, in some cases this by shifting before adding and in other cases by evaluating the operands 4. Unrolled loops to speed up processing 5. Replaced mpy_32_16 by multpilcations in place 6. Eliminated if-else statements for sign extension when right-shifting Description: Added casting to eliminate warnings, and eliminated include files that now are chosen by OSCL definitions Description: Replaced "int" and/or "char" with defined types. Added proper casting (Word32) to some left shifting operations Who: Date: Description: ------------------------------------------------------------------------------ MODULE DESCRIPTION This file contains functions that convert line spectral pairs (LSP) to linear predictive (LP) coefficients (filter order = 10). The functions included in this file include Get_lsp_pol, which finds the coefficients of F1(z) and F2(z), and Lsp_Az, which converts LSP to LPC by multiplying F1(z) by 1+z^(-1) and F2(z) by 1-z^(-1), then calculating A(z) = (F1(z) + F2(z))/2. ------------------------------------------------------------------------------ */ /*---------------------------------------------------------------------------- ; INCLUDES ----------------------------------------------------------------------------*/ #include "lsp_az.h" /*---------------------------------------------------------------------------- ; MACROS ; Define module specific macros here ----------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------- ; DEFINES ; Include all pre-processor statements here. Include conditional ; compile variables also. ----------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------- ; LOCAL FUNCTION DEFINITIONS ; Function Prototype declaration ----------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------- ; LOCAL VARIABLE DEFINITIONS ; Variable declaration - defined here and used outside this module ----------------------------------------------------------------------------*/ /* ------------------------------------------------------------------------------ FUNCTION NAME: Get_lsp_pol ------------------------------------------------------------------------------ INPUT AND OUTPUT DEFINITIONS Inputs: lsp = pointer to the buffer containing the line spectral pairs (LSP) of type Word16 f = pointer to the polynomial of type Word32 to be generated pOverflow = pointer set in case where one of the operations overflows. [data type Pointer to Flag] Outputs: buffer pointed to by f contains the polynomial generated pOverflow = pointer set in case where one of the operations overflows. [data type Pointer to Flag] Returns: None Global Variables Used: None Local Variables Needed: None ------------------------------------------------------------------------------ FUNCTION DESCRIPTION This function finds the polynomial F1(z) or F2(z) from the LSPs. If the LSP vector is passed at address 0, F1(z) is computed and if it is passed at address 1, F2(z) is computed. This is performed by expanding the product polynomials: F1(z) = product ( 1 - 2 lsp[i] z^-1 + z^-2 ) i=0,2,4,6,8 F2(z) = product ( 1 - 2 lsp[i] z^-1 + z^-2 ) i=1,3,5,7,9 where lsp[] is the LSP vector in the cosine domain. The expansion is performed using the following recursion: f[0] = 1 b = -2.0 * lsp[0] f[1] = b for i=2 to 5 do b = -2.0 * lsp[2*i-2]; for j=i-1 down to 2 do f[j] = f[j] + b*f[j-1] + f[j-2]; f[1] = f[1] + b; ------------------------------------------------------------------------------ REQUIREMENTS None ------------------------------------------------------------------------------ REFERENCES lsp_az.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001 ------------------------------------------------------------------------------ PSEUDO-CODE static void Get_lsp_pol (Word16 *lsp, Word32 *f) { Word16 i, j, hi, lo; Word32 t0; // f[0] = 1.0; *f = L_mult (4096, 2048); f++; *f = L_msu ((Word32) 0, *lsp, 512); // f[1] = -2.0 * lsp[0]; f++; lsp += 2; // Advance lsp pointer for (i = 2; i <= 5; i++) { *f = f[-2]; for (j = 1; j < i; j++, f--) { L_Extract (f[-1], &hi, &lo); t0 = Mpy_32_16 (hi, lo, *lsp); // t0 = f[-1] * lsp t0 = L_shl (t0, 1); *f = L_add (*f, f[-2]); // *f += f[-2] *f = L_sub (*f, t0); // *f -= t0 } *f = L_msu (*f, *lsp, 512); // *f -= lsp<<9 f += i; // Advance f pointer lsp += 2; // Advance lsp pointer } return; } ------------------------------------------------------------------------------ RESOURCES USED [optional] When the code is written for a specific target processor the the resources used should be documented below. HEAP MEMORY USED: x bytes STACK MEMORY USED: x bytes CLOCK CYCLES: (cycle count equation for this function) + (variable used to represent cycle count for each subroutine called) where: (cycle count variable) = cycle count for [subroutine name] ------------------------------------------------------------------------------ CAUTION [optional] [State any special notes, constraints or cautions for users of this function] ------------------------------------------------------------------------------ */ static void Get_lsp_pol( Word16 *lsp, Word32 *f, Flag *pOverflow) { Word16 i; Word16 j; Word16 hi; Word16 lo; Word32 t0; OSCL_UNUSED_ARG(pOverflow); /* f[0] = 1.0; */ *f++ = (Word32) 0x01000000; *f++ = (Word32) - *(lsp++) << 10; /* f[1] = -2.0 * lsp[0]; */ lsp++; /* Advance lsp pointer */ for (i = 2; i <= 5; i++) { *f = *(f - 2); for (j = 1; j < i; j++) { hi = (Word16)(*(f - 1) >> 16); lo = (Word16)((*(f - 1) >> 1) - ((Word32) hi << 15)); t0 = ((Word32)hi * *lsp); t0 += ((Word32)lo * *lsp) >> 15; *(f) += *(f - 2); /* *f += f[-2] */ __builtin_sub_overflow(*(f), (t0 << 2), f); /* *f -= t0 */ f--; } *f -= (Word32)(*lsp++) << 10; f += i; lsp++; } return; } /****************************************************************************/ /* ------------------------------------------------------------------------------ FUNCTION NAME: Get_lsp_pol_wrapper ------------------------------------------------------------------------------ INPUT AND OUTPUT DEFINITIONS Inputs: lsp = pointer to the buffer containing the line spectral pairs (LSP) of type Word16 f = pointer to the polynomial of type Word32 to be generated pOverflow = pointer set in case where one of the operations overflows. [data type Pointer to Flag] Outputs: buffer pointed to by f contains the polynomial generated pOverflow = pointer set in case where one of the operations overflows. [data type Pointer to Flag] Returns: None Global Variables Used: None Local Variables Needed: None ------------------------------------------------------------------------------ FUNCTION DESCRIPTION This function provides external access to the static function Get_lsp_pol. ------------------------------------------------------------------------------ REQUIREMENTS None ------------------------------------------------------------------------------ REFERENCES None ------------------------------------------------------------------------------ PSEUDO-CODE CALL Get_lsp_pol(lsp = lsp_ptr f = f_ptr ) MODIFYING(nothing) RETURNING(nothing) ------------------------------------------------------------------------------ RESOURCES USED [optional] When the code is written for a specific target processor the the resources used should be documented below. HEAP MEMORY USED: x bytes STACK MEMORY USED: x bytes CLOCK CYCLES: (cycle count equation for this function) + (variable used to represent cycle count for each subroutine called) where: (cycle count variable) = cycle count for [subroutine name] ------------------------------------------------------------------------------ CAUTION [optional] [State any special notes, constraints or cautions for users of this function] ------------------------------------------------------------------------------ */ void Get_lsp_pol_wrapper( Word16 *lsp, Word32 *f, Flag *pOverflow) { /*---------------------------------------------------------------------------- CALL Get_lsp_pol(lsp = lsp_ptr f = f_ptr ) ----------------------------------------------------------------------------*/ Get_lsp_pol(lsp, f, pOverflow); /*---------------------------------------------------------------------------- MODIFYING(nothing) RETURNING(nothing) ----------------------------------------------------------------------------*/ return; } /****************************************************************************/ /* ------------------------------------------------------------------------------ FUNCTION NAME: Lsp_Az ------------------------------------------------------------------------------ INPUT AND OUTPUT DEFINITIONS Inputs: lsp = pointer to the buffer containing the line spectral pairs (LSP) of type Word16 a = pointer to the buffer containing Linear Predictive (LP) coefficients of type Word16 to be generated pOverflow = pointer set in case where one of the operations overflows. [data type Pointer to Flag] Local Stores/Buffers/Pointers Needed: None Global Stores/Buffers/Pointers Needed: None Outputs: pOverflow = pointer set in case where one of the operations overflows. [data type Pointer to Flag] Pointers and Buffers Modified: a buffer contains the generated Linear Predictive (LP) coefficients Local Stores Modified: None Global Stores Modified: None ------------------------------------------------------------------------------ FUNCTION DESCRIPTION This function converts from the line spectral pairs (LSP) to LP coefficients for a 10th order filter. This is done by: (1) Find the coefficients of F1(z) and F2(z) (see Get_lsp_pol) (2) Multiply F1(z) by 1+z^{-1} and F2(z) by 1-z^{-1} (3) A(z) = ( F1(z) + F2(z) ) / 2 ------------------------------------------------------------------------------ REQUIREMENTS None ------------------------------------------------------------------------------ REFERENCES lsp_az.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001 ------------------------------------------------------------------------------ PSEUDO-CODE void Lsp_Az ( Word16 lsp[], // (i) : line spectral frequencies Word16 a[] // (o) : predictor coefficients (order = 10) ) { Word16 i, j; Word32 f1[6], f2[6]; Word32 t0; Get_lsp_pol (&lsp[0], f1); Get_lsp_pol (&lsp[1], f2); for (i = 5; i > 0; i--) { f1[i] = L_add (f1[i], f1[i - 1]); // f1[i] += f1[i-1]; f2[i] = L_sub (f2[i], f2[i - 1]); // f2[i] -= f2[i-1]; } a[0] = 4096; for (i = 1, j = 10; i <= 5; i++, j--) { t0 = L_add (f1[i], f2[i]); // f1[i] + f2[i] a[i] = extract_l (L_shr_r (t0, 13)); t0 = L_sub (f1[i], f2[i]); // f1[i] - f2[i] a[j] = extract_l (L_shr_r (t0, 13)); } return; } ------------------------------------------------------------------------------ RESOURCES USED [optional] When the code is written for a specific target processor the the resources used should be documented below. HEAP MEMORY USED: x bytes STACK MEMORY USED: x bytes CLOCK CYCLES: (cycle count equation for this function) + (variable used to represent cycle count for each subroutine called) where: (cycle count variable) = cycle count for [subroutine name] ------------------------------------------------------------------------------ CAUTION [optional] [State any special notes, constraints or cautions for users of this function] ------------------------------------------------------------------------------ */ void Lsp_Az( Word16 lsp[], /* (i) : line spectral frequencies */ Word16 a[], /* (o) : predictor coefficients (order = 10) */ Flag *pOverflow /* (o) : overflow flag */ ) { Word16 i; Word16 j; Word32 f1[6]; Word32 f2[6]; Word32 t0; Word32 t1; Word16 *p_a = &a[0]; Word32 *p_f1; Word32 *p_f2; Get_lsp_pol(&lsp[0], f1, pOverflow); Get_lsp_pol(&lsp[1], f2, pOverflow); p_f1 = &f1[5]; p_f2 = &f2[5]; for (i = 5; i > 0; i--) { *(p_f1--) += f1[i-1]; *(p_f2--) -= f2[i-1]; } *(p_a++) = 4096; p_f1 = &f1[1]; p_f2 = &f2[1]; for (i = 1, j = 10; i <= 5; i++, j--) { t0 = *(p_f1) + *(p_f2); /* f1[i] + f2[i] */ t1 = *(p_f1++) - *(p_f2++); /* f1[i] - f2[i] */ t0 = t0 + ((Word32) 1 << 12); t1 = t1 + ((Word32) 1 << 12); *(p_a++) = (Word16)(t0 >> 13); a[j] = (Word16)(t1 >> 13); } return; }