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 Pathname: ./include/basic_op_c_equivalent.h 32 33 ------------------------------------------------------------------------------ 34 REVISION HISTORY 35 36 Who: Date: 37 Description: 38 39 ------------------------------------------------------------------------------ 40 INCLUDE DESCRIPTION 41 42 This file includes all the C-Equivalent basicop.c functions. 43 44 ------------------------------------------------------------------------------ 45 */ 46 47 /*---------------------------------------------------------------------------- 48 ; CONTINUE ONLY IF NOT ALREADY DEFINED 49 ----------------------------------------------------------------------------*/ 50 #ifndef BASIC_OP_C_EQUIVALENT_H 51 #define BASIC_OP_C_EQUIVALENT_H 52 53 /*---------------------------------------------------------------------------- 54 ; INCLUDES 55 ----------------------------------------------------------------------------*/ 56 #include "basicop_malloc.h" 57 58 /*--------------------------------------------------------------------------*/ 59 #ifdef __cplusplus 60 extern "C" 61 { 62 #endif 63 64 /*---------------------------------------------------------------------------- 65 ; MACROS 66 ; Define module specific macros here 67 ----------------------------------------------------------------------------*/ 68 69 /*---------------------------------------------------------------------------- 70 ; DEFINES 71 ; Include all pre-processor statements here. 72 ----------------------------------------------------------------------------*/ 73 74 /*---------------------------------------------------------------------------- 75 ; EXTERNAL VARIABLES REFERENCES 76 ; Declare variables used in this module but defined elsewhere 77 ----------------------------------------------------------------------------*/ 78 79 /*---------------------------------------------------------------------------- 80 ; SIMPLE TYPEDEF'S 81 ----------------------------------------------------------------------------*/ 82 83 /*---------------------------------------------------------------------------- 84 ; ENUMERATED TYPEDEF'S 85 ----------------------------------------------------------------------------*/ 86 87 /*---------------------------------------------------------------------------- 88 ; STRUCTURES TYPEDEF'S 89 ----------------------------------------------------------------------------*/ 90 91 /*---------------------------------------------------------------------------- 92 ; GLOBAL FUNCTION DEFINITIONS 93 ; Function Prototype declaration 94 ----------------------------------------------------------------------------*/ 95 96 97 /* 98 ------------------------------------------------------------------------------ 99 FUNCTION NAME: L_add 100 ------------------------------------------------------------------------------ 101 INPUT AND OUTPUT DEFINITIONS 102 103 Inputs: 104 L_var1 = 32 bit long signed integer (Word32) whose value falls 105 in the range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. 106 107 L_var2 = 32 bit long signed integer (Word32) whose value falls 108 in the range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. 109 110 pOverflow = pointer to overflow (Flag) 111 112 Outputs: 113 pOverflow -> 1 if the 32 bit add operation resulted in overflow 114 115 Returns: 116 L_sum = 32-bit sum of L_var1 and L_var2 (Word32) 117 */ 118 __attribute__((no_sanitize("integer"))) 119 static inline Word32 L_add(Word32 L_var1, Word32 L_var2, Flag *pOverflow) 120 { 121 Word32 L_sum; 122 123 L_sum = L_var1 + L_var2; 124 125 if ((L_var1 ^ L_var2) >= 0) 126 { 127 if ((L_sum ^ L_var1) < 0) 128 { 129 L_sum = (L_var1 < 0) ? MIN_32 : MAX_32; 130 *pOverflow = 1; 131 } 132 } 133 134 return (L_sum); 135 } 136 137 /* 138 ------------------------------------------------------------------------------ 139 FUNCTION NAME: L_sub 140 ------------------------------------------------------------------------------ 141 INPUT AND OUTPUT DEFINITIONS 142 143 Inputs: 144 L_var1 = 32 bit long signed integer (Word32) whose value falls 145 in the range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. 146 147 L_var2 = 32 bit long signed integer (Word32) whose value falls 148 in the range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. 149 150 pOverflow = pointer to overflow (Flag) 151 152 Outputs: 153 pOverflow -> 1 if the 32 bit add operation resulted in overflow 154 155 Returns: 156 L_diff = 32-bit difference of L_var1 and L_var2 (Word32) 157 */ 158 static inline Word32 L_sub(Word32 L_var1, Word32 L_var2, 159 Flag *pOverflow) 160 { 161 Word32 L_diff; 162 163 L_diff = L_var1 - L_var2; 164 165 if ((L_var1 ^ L_var2) < 0) 166 { 167 if ((L_diff ^ L_var1) & MIN_32) 168 { 169 L_diff = (L_var1 < 0L) ? MIN_32 : MAX_32; 170 *pOverflow = 1; 171 } 172 } 173 174 return (L_diff); 175 } 176 177 178 /* 179 ------------------------------------------------------------------------------ 180 FUNCTION NAME: L_mac 181 ------------------------------------------------------------------------------ 182 INPUT AND OUTPUT DEFINITIONS 183 184 Inputs: 185 L_var3 = 32 bit long signed integer (Word32) whose value falls 186 in the range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. 187 var1 = 16 bit short signed integer (Word16) whose value falls in 188 the range : 0xffff 8000 <= var1 <= 0x0000 7fff. 189 var2 = 16 bit short signed integer (Word16) whose value falls in 190 the range : 0xffff 8000 <= var2 <= 0x0000 7fff. 191 192 pOverflow = pointer to overflow (Flag) 193 194 Outputs: 195 pOverflow -> 1 if the 32 bit add operation resulted in overflow 196 197 Returns: 198 result = 32-bit result of L_var3 + (var1 * var2)(Word32) 199 */ 200 __inline Word32 L_mac(Word32 L_var3, Word16 var1, Word16 var2, Flag *pOverflow) 201 { 202 Word32 result; 203 Word32 L_sum; 204 result = (Word32) var1 * var2; 205 if (result != (Word32) 0x40000000L) 206 { 207 L_sum = (result << 1) + L_var3; 208 209 /* Check if L_sum and L_var_3 share the same sign */ 210 if ((L_var3 ^ result) > 0) 211 { 212 if ((L_sum ^ L_var3) < 0) 213 { 214 L_sum = (L_var3 < 0) ? MIN_32 : MAX_32; 215 *pOverflow = 1; 216 } 217 } 218 } 219 else 220 { 221 *pOverflow = 1; 222 L_sum = MAX_32; 223 } 224 return (L_sum); 225 } 226 227 /* 228 ------------------------------------------------------------------------------ 229 FUNCTION NAME: L_mult 230 ------------------------------------------------------------------------------ 231 INPUT AND OUTPUT DEFINITIONS 232 233 Inputs: 234 L_var1 = 16 bit short signed integer (Word16) whose value falls in 235 the range : 0xffff 8000 <= var1 <= 0x0000 7fff. 236 237 L_var2 = 16 bit short signed integer (Word16) whose value falls in 238 the range : 0xffff 8000 <= var1 <= 0x0000 7fff. 239 240 pOverflow = pointer to overflow (Flag) 241 242 Outputs: 243 pOverflow -> 1 if the 32 bit add operation resulted in overflow 244 245 Returns: 246 L_product = 32-bit product of L_var1 and L_var2 (Word32) 247 */ 248 static inline Word32 L_mult(Word16 var1, Word16 var2, Flag *pOverflow) 249 { 250 Word32 L_product; 251 252 L_product = (Word32) var1 * var2; 253 254 if (L_product != (Word32) 0x40000000L) 255 { 256 L_product <<= 1; /* Multiply by 2 */ 257 } 258 else 259 { 260 *pOverflow = 1; 261 L_product = MAX_32; 262 } 263 264 return (L_product); 265 } 266 267 268 /* 269 ------------------------------------------------------------------------------ 270 FUNCTION NAME: L_msu 271 ------------------------------------------------------------------------------ 272 INPUT AND OUTPUT DEFINITIONS 273 274 Inputs: 275 L_var3 = 32 bit long signed integer (Word32) whose value falls 276 in the range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. 277 278 var1 = 16 bit short signed integer (Word16) whose value falls in 279 the range : 0xffff 8000 <= var1 <= 0x0000 7fff. 280 var2 = 16 bit short signed integer (Word16) whose value falls in 281 the range : 0xffff 8000 <= var2 <= 0x0000 7fff. 282 283 pOverflow = pointer to overflow (Flag) 284 285 Outputs: 286 pOverflow -> 1 if the 32 bit operation resulted in overflow 287 288 Returns: 289 result = 32-bit result of L_var3 - (var1 * var2) 290 */ 291 292 static inline Word32 L_msu(Word32 L_var3, Word16 var1, Word16 var2, Flag *pOverflow) 293 { 294 Word32 result; 295 296 result = L_mult(var1, var2, pOverflow); 297 result = L_sub(L_var3, result, pOverflow); 298 299 return (result); 300 } 301 302 /* 303 ------------------------------------------------------------------------------ 304 FUNCTION NAME: Mpy_32 305 ------------------------------------------------------------------------------ 306 INPUT AND OUTPUT DEFINITIONS 307 308 Inputs: 309 L_var1_hi = most significant word of first input (Word16). 310 L_var1_lo = least significant word of first input (Word16). 311 L_var2_hi = most significant word of second input (Word16). 312 L_var2_lo = least significant word of second input (Word16). 313 314 pOverflow = pointer to overflow (Flag) 315 316 Outputs: 317 pOverflow -> 1 if the 32 bit multiply operation resulted in overflow 318 319 Returns: 320 L_product = 32-bit product of L_var1 and L_var2 (Word32) 321 */ 322 __inline Word32 Mpy_32(Word16 L_var1_hi, 323 Word16 L_var1_lo, 324 Word16 L_var2_hi, 325 Word16 L_var2_lo, 326 Flag *pOverflow) 327 { 328 Word32 L_product; 329 Word32 L_sum; 330 Word32 product32; 331 332 OSCL_UNUSED_ARG(pOverflow); 333 L_product = (Word32) L_var1_hi * L_var2_hi; 334 335 if (L_product != (Word32) 0x40000000L) 336 { 337 L_product <<= 1; 338 } 339 else 340 { 341 L_product = MAX_32; 342 } 343 344 /* result = mult (L_var1_hi, L_var2_lo, pOverflow); */ 345 product32 = ((Word32) L_var1_hi * L_var2_lo) >> 15; 346 347 /* L_product = L_mac (L_product, result, 1, pOverflow); */ 348 L_sum = L_product + (product32 << 1); 349 350 if ((L_product ^ product32) > 0) 351 { 352 if ((L_sum ^ L_product) < 0) 353 { 354 L_sum = (L_product < 0) ? MIN_32 : MAX_32; 355 } 356 } 357 358 L_product = L_sum; 359 360 /* result = mult (L_var1_lo, L_var2_hi, pOverflow); */ 361 product32 = ((Word32) L_var1_lo * L_var2_hi) >> 15; 362 363 /* L_product = L_mac (L_product, result, 1, pOverflow); */ 364 L_sum = L_product + (product32 << 1); 365 366 if ((L_product ^ product32) > 0) 367 { 368 if ((L_sum ^ L_product) < 0) 369 { 370 L_sum = (L_product < 0) ? MIN_32 : MAX_32; 371 } 372 } 373 return (L_sum); 374 } 375 376 /* 377 ------------------------------------------------------------------------------ 378 FUNCTION NAME: Mpy_32_16 379 ------------------------------------------------------------------------------ 380 INPUT AND OUTPUT DEFINITIONS 381 382 Inputs: 383 L_var1_hi = most significant 16 bits of 32-bit input (Word16). 384 L_var1_lo = least significant 16 bits of 32-bit input (Word16). 385 var2 = 16-bit signed integer (Word16). 386 387 pOverflow = pointer to overflow (Flag) 388 389 Outputs: 390 pOverflow -> 1 if the 32 bit product operation resulted in overflow 391 392 Returns: 393 product = 32-bit product of the 32-bit L_var1 and 16-bit var1 (Word32) 394 */ 395 396 __inline Word32 Mpy_32_16(Word16 L_var1_hi, 397 Word16 L_var1_lo, 398 Word16 var2, 399 Flag *pOverflow) 400 { 401 402 Word32 L_product; 403 Word32 L_sum; 404 Word32 result; 405 L_product = (Word32) L_var1_hi * var2; 406 407 if (L_product != (Word32) 0x40000000L) 408 { 409 L_product <<= 1; 410 } 411 else 412 { 413 *pOverflow = 1; 414 L_product = MAX_32; 415 } 416 417 result = ((Word32)L_var1_lo * var2) >> 15; 418 419 L_sum = L_product + (result << 1); 420 421 if ((L_product ^ result) > 0) 422 { 423 if ((L_sum ^ L_product) < 0) 424 { 425 L_sum = (L_product < 0) ? MIN_32 : MAX_32; 426 *pOverflow = 1; 427 } 428 } 429 return (L_sum); 430 431 } 432 433 /* 434 ------------------------------------------------------------------------------ 435 FUNCTION NAME: mult 436 ------------------------------------------------------------------------------ 437 INPUT AND OUTPUT DEFINITIONS 438 439 Inputs: 440 var1 = 16 bit short signed integer (Word16) whose value falls in 441 the range : 0xffff 8000 <= var1 <= 0x0000 7fff. 442 443 var2 = 16 bit short signed integer (Word16) whose value falls in 444 the range : 0xffff 8000 <= var2 <= 0x0000 7fff. 445 446 pOverflow = pointer to overflow (Flag) 447 448 Outputs: 449 pOverflow -> 1 if the add operation resulted in overflow 450 451 Returns: 452 product = 16-bit limited product of var1 and var2 (Word16) 453 */ 454 static inline Word16 mult(Word16 var1, Word16 var2, Flag *pOverflow) 455 { 456 Word32 product; 457 458 product = ((Word32) var1 * var2) >> 15; 459 460 /* Saturate result (if necessary). */ 461 /* var1 * var2 >0x00007fff is the only case */ 462 /* that saturation occurs. */ 463 464 if (product > 0x00007fffL) 465 { 466 *pOverflow = 1; 467 product = (Word32) MAX_16; 468 } 469 470 471 /* Return the product as a 16 bit value by type casting Word32 to Word16 */ 472 473 return ((Word16) product); 474 } 475 476 477 static inline Word32 amrnb_fxp_mac_16_by_16bb(Word32 L_var1, Word32 L_var2, Word32 L_var3) 478 { 479 Word32 result; 480 481 result = L_var3 + L_var1 * L_var2; 482 483 return result; 484 } 485 486 static inline Word32 amrnb_fxp_msu_16_by_16bb(Word32 L_var1, Word32 L_var2, Word32 L_var3) 487 { 488 Word32 result; 489 490 result = L_var3 - L_var1 * L_var2; 491 492 return result; 493 } 494 495 496 /*---------------------------------------------------------------------------- 497 ; END 498 ----------------------------------------------------------------------------*/ 499 #ifdef __cplusplus 500 } 501 #endif 502 503 #endif /* BASIC_OP_C_EQUIVALENT_H */ 504 505 506 507
