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 /**************************************************************************************** 19 Portions 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) 26 Permission to distribute, modify and use this file under the standard license 27 terms listed above has been obtained from the copyright holder. 28 ****************************************************************************************/ 29 /* 30 ------------------------------------------------------------------------------ 31 32 33 34 Filename: /audio/gsm-amr/c/src/a_refl.c 35 Functions: a_refl 36 37 Date: 02/05/2002 38 39 ------------------------------------------------------------------------------ 40 REVISION HISTORY 41 42 Description: Removing unneeded include files and the goto statement. 43 44 45 Description: Changed function name to pv_round to avoid conflict with 46 round function in C standard library. 47 48 Description: Replaced "int" and/or "char" with OSCL defined types. 49 50 Description: Using inline functions from basic_op.h . 51 Removing unneeded include files. 52 53 Description: 54 55 ------------------------------------------------------------------------------ 56 */ 57 58 59 /*---------------------------------------------------------------------------- 60 ; INCLUDES 61 ----------------------------------------------------------------------------*/ 62 #include "a_refl.h" 63 #include "typedef.h" 64 #include "cnst.h" 65 #include "basic_op.h" 66 67 /*---------------------------------------------------------------------------- 68 ; MACROS [optional] 69 ; [Define module specific macros here] 70 ----------------------------------------------------------------------------*/ 71 72 /*---------------------------------------------------------------------------- 73 ; DEFINES [optional] 74 ; [Include all pre-processor statements here. Include conditional 75 ; compile variables also.] 76 ----------------------------------------------------------------------------*/ 77 78 /*---------------------------------------------------------------------------- 79 ; LOCAL FUNCTION DEFINITIONS 80 ; [List function prototypes here] 81 ----------------------------------------------------------------------------*/ 82 83 /*---------------------------------------------------------------------------- 84 ; LOCAL VARIABLE DEFINITIONS 85 ; [Variable declaration - defined here and used outside this module] 86 ----------------------------------------------------------------------------*/ 87 88 /* 89 ------------------------------------------------------------------------------ 90 FUNCTION NAME: AMREncode 91 ------------------------------------------------------------------------------ 92 INPUT AND OUTPUT DEFINITIONS 93 94 Inputs: 95 a[] = pointer to directform coefficients of type Word16 96 refl[] = pointer to reflection coefficients of type Word16 97 98 Outputs: 99 pOverflow = 1 if overflow exists in the math operations else zero. 100 101 Returns: 102 None 103 104 Global Variables Used: 105 None 106 107 Local Variables Needed: 108 None 109 110 ------------------------------------------------------------------------------ 111 FUNCTION DESCRIPTION 112 113 File : a_refl.c 114 Purpose : Convert from direct form coefficients to 115 reflection coefficients 116 117 ------------------------------------------------------------------------------ 118 REQUIREMENTS 119 120 None 121 122 ------------------------------------------------------------------------------ 123 REFERENCES 124 125 [1] a_refl.c , 3GPP TS 26.101 version 4.1.0 Release 4, June 2001 126 127 ------------------------------------------------------------------------------ 128 PSEUDO-CODE 129 130 131 void A_Refl( 132 Word16 a[], // i : Directform coefficients 133 Word16 refl[] // o : Reflection coefficients 134 ) 135 { 136 // local variables 137 Word16 i,j; 138 Word16 aState[M]; 139 Word16 bState[M]; 140 Word16 normShift; 141 Word16 normProd; 142 Word32 L_acc; 143 Word16 scale; 144 Word32 L_temp; 145 Word16 temp; 146 Word16 mult; 147 148 // initialize states 149 for (i = 0; i < M; i++) 150 { 151 aState[i] = a[i]; 152 } 153 154 // backward Levinson recursion 155 for (i = M-1; i >= 0; i--) 156 { 157 if (sub(abs_s(aState[i]), 4096) >= 0) 158 { 159 goto ExitRefl; 160 } 161 162 refl[i] = shl(aState[i], 3); 163 164 L_temp = L_mult(refl[i], refl[i]); 165 L_acc = L_sub(MAX_32, L_temp); 166 167 normShift = norm_l(L_acc); 168 scale = sub(15, normShift); 169 170 L_acc = L_shl(L_acc, normShift); 171 normProd = pv_round(L_acc); 172 173 mult = div_s(16384, normProd); 174 175 for (j = 0; j < i; j++) 176 { 177 L_acc = L_deposit_h(aState[j]); 178 L_acc = L_msu(L_acc, refl[i], aState[i-j-1]); 179 180 temp = pv_round(L_acc); 181 L_temp = L_mult(mult, temp); 182 L_temp = L_shr_r(L_temp, scale); 183 184 if (L_sub(L_abs(L_temp), 32767) > 0) 185 { 186 goto ExitRefl; 187 } 188 189 bState[j] = extract_l(L_temp); 190 } 191 192 for (j = 0; j < i; j++) 193 { 194 aState[j] = bState[j]; 195 } 196 } 197 return; 198 199 ExitRefl: 200 for (i = 0; i < M; i++) 201 { 202 refl[i] = 0; 203 } 204 } 205 206 ------------------------------------------------------------------------------ 207 RESOURCES USED [optional] 208 209 When the code is written for a specific target processor the 210 the resources used should be documented below. 211 212 HEAP MEMORY USED: x bytes 213 214 STACK MEMORY USED: x bytes 215 216 CLOCK CYCLES: (cycle count equation for this function) + (variable 217 used to represent cycle count for each subroutine 218 called) 219 where: (cycle count variable) = cycle count for [subroutine 220 name] 221 222 ------------------------------------------------------------------------------ 223 CAUTION [optional] 224 [State any special notes, constraints or cautions for users of this function] 225 226 ------------------------------------------------------------------------------ 227 */ 228 229 void A_Refl( 230 Word16 a[], /* i : Directform coefficients */ 231 Word16 refl[], /* o : Reflection coefficients */ 232 Flag *pOverflow 233 ) 234 { 235 /* local variables */ 236 Word16 i; 237 Word16 j; 238 Word16 aState[M]; 239 Word16 bState[M]; 240 Word16 normShift; 241 Word16 normProd; 242 Word32 L_acc; 243 Word16 scale; 244 Word32 L_temp; 245 Word16 temp; 246 Word16 mult; 247 248 /* initialize states */ 249 for (i = 0; i < M; i++) 250 { 251 aState[i] = a[i]; 252 } 253 254 /* backward Levinson recursion */ 255 for (i = M - 1; i >= 0; i--) 256 { 257 if (abs_s(aState[i]) >= 4096) 258 { 259 for (i = 0; i < M; i++) 260 { 261 refl[i] = 0; 262 } 263 break; 264 } 265 266 refl[i] = shl(aState[i], 3, pOverflow); 267 268 L_temp = L_mult(refl[i], refl[i], pOverflow); 269 L_acc = L_sub(MAX_32, L_temp, pOverflow); 270 271 normShift = norm_l(L_acc); 272 scale = sub(15, normShift, pOverflow); 273 274 L_acc = L_shl(L_acc, normShift, pOverflow); 275 normProd = pv_round(L_acc, pOverflow); 276 277 mult = div_s(16384, normProd); 278 279 for (j = 0; j < i; j++) 280 { 281 L_acc = L_deposit_h(aState[j]); 282 L_acc = L_msu(L_acc, refl[i], aState[i-j-1], pOverflow); 283 284 temp = pv_round(L_acc, pOverflow); 285 L_temp = L_mult(mult, temp, pOverflow); 286 L_temp = L_shr_r(L_temp, scale, pOverflow); 287 288 if (L_abs(L_temp) > 32767) 289 { 290 for (i = 0; i < M; i++) 291 { 292 refl[i] = 0; 293 } 294 break; 295 } 296 297 bState[j] = extract_l(L_temp); 298 } 299 300 for (j = 0; j < i; j++) 301 { 302 aState[j] = bState[j]; 303 } 304 } 305 return; 306 } 307 308 309 310 311 312 313 314
