1 /* ----------------------------------------------------------------------------- 2 Software License for The Fraunhofer FDK AAC Codec Library for Android 3 4 Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Frderung der angewandten 5 Forschung e.V. All rights reserved. 6 7 1. INTRODUCTION 8 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software 9 that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding 10 scheme for digital audio. This FDK AAC Codec software is intended to be used on 11 a wide variety of Android devices. 12 13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient 14 general perceptual audio codecs. AAC-ELD is considered the best-performing 15 full-bandwidth communications codec by independent studies and is widely 16 deployed. AAC has been standardized by ISO and IEC as part of the MPEG 17 specifications. 18 19 Patent licenses for necessary patent claims for the FDK AAC Codec (including 20 those of Fraunhofer) may be obtained through Via Licensing 21 (www.vialicensing.com) or through the respective patent owners individually for 22 the purpose of encoding or decoding bit streams in products that are compliant 23 with the ISO/IEC MPEG audio standards. Please note that most manufacturers of 24 Android devices already license these patent claims through Via Licensing or 25 directly from the patent owners, and therefore FDK AAC Codec software may 26 already be covered under those patent licenses when it is used for those 27 licensed purposes only. 28 29 Commercially-licensed AAC software libraries, including floating-point versions 30 with enhanced sound quality, are also available from Fraunhofer. Users are 31 encouraged to check the Fraunhofer website for additional applications 32 information and documentation. 33 34 2. COPYRIGHT LICENSE 35 36 Redistribution and use in source and binary forms, with or without modification, 37 are permitted without payment of copyright license fees provided that you 38 satisfy the following conditions: 39 40 You must retain the complete text of this software license in redistributions of 41 the FDK AAC Codec or your modifications thereto in source code form. 42 43 You must retain the complete text of this software license in the documentation 44 and/or other materials provided with redistributions of the FDK AAC Codec or 45 your modifications thereto in binary form. You must make available free of 46 charge copies of the complete source code of the FDK AAC Codec and your 47 modifications thereto to recipients of copies in binary form. 48 49 The name of Fraunhofer may not be used to endorse or promote products derived 50 from this library without prior written permission. 51 52 You may not charge copyright license fees for anyone to use, copy or distribute 53 the FDK AAC Codec software or your modifications thereto. 54 55 Your modified versions of the FDK AAC Codec must carry prominent notices stating 56 that you changed the software and the date of any change. For modified versions 57 of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android" 58 must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK 59 AAC Codec Library for Android." 60 61 3. NO PATENT LICENSE 62 63 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without 64 limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE. 65 Fraunhofer provides no warranty of patent non-infringement with respect to this 66 software. 67 68 You may use this FDK AAC Codec software or modifications thereto only for 69 purposes that are authorized by appropriate patent licenses. 70 71 4. DISCLAIMER 72 73 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright 74 holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, 75 including but not limited to the implied warranties of merchantability and 76 fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 77 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, 78 or consequential damages, including but not limited to procurement of substitute 79 goods or services; loss of use, data, or profits, or business interruption, 80 however caused and on any theory of liability, whether in contract, strict 81 liability, or tort (including negligence), arising in any way out of the use of 82 this software, even if advised of the possibility of such damage. 83 84 5. CONTACT INFORMATION 85 86 Fraunhofer Institute for Integrated Circuits IIS 87 Attention: Audio and Multimedia Departments - FDK AAC LL 88 Am Wolfsmantel 33 89 91058 Erlangen, Germany 90 91 www.iis.fraunhofer.de/amm 92 amm-info (at) iis.fraunhofer.de 93 ----------------------------------------------------------------------------- */ 94 95 /******************* Library for basic calculation routines ******************** 96 97 Author(s): 98 99 Description: Scaling operations 100 101 *******************************************************************************/ 102 103 #include "common_fix.h" 104 105 #include "genericStds.h" 106 107 /************************************************** 108 * Inline definitions 109 **************************************************/ 110 111 #include "scale.h" 112 113 #if defined(__mips__) 114 #include "mips/scale_mips.cpp" 115 116 #elif defined(__arm__) 117 #include "arm/scale_arm.cpp" 118 119 #endif 120 121 #ifndef FUNCTION_scaleValues_SGL 122 /*! 123 * 124 * \brief Multiply input vector by \f$ 2^{scalefactor} \f$ 125 * \param len must be larger than 4 126 * \return void 127 * 128 */ 129 #define FUNCTION_scaleValues_SGL 130 void scaleValues(FIXP_SGL *vector, /*!< Vector */ 131 INT len, /*!< Length */ 132 INT scalefactor /*!< Scalefactor */ 133 ) { 134 INT i; 135 136 /* Return if scalefactor is Zero */ 137 if (scalefactor == 0) return; 138 139 if (scalefactor > 0) { 140 scalefactor = fixmin_I(scalefactor, (INT)(FRACT_BITS - 1)); 141 for (i = len & 3; i--;) { 142 *(vector++) <<= scalefactor; 143 } 144 for (i = len >> 2; i--;) { 145 *(vector++) <<= scalefactor; 146 *(vector++) <<= scalefactor; 147 *(vector++) <<= scalefactor; 148 *(vector++) <<= scalefactor; 149 } 150 } else { 151 INT negScalefactor = fixmin_I(-scalefactor, (INT)FRACT_BITS - 1); 152 for (i = len & 3; i--;) { 153 *(vector++) >>= negScalefactor; 154 } 155 for (i = len >> 2; i--;) { 156 *(vector++) >>= negScalefactor; 157 *(vector++) >>= negScalefactor; 158 *(vector++) >>= negScalefactor; 159 *(vector++) >>= negScalefactor; 160 } 161 } 162 } 163 #endif 164 165 #ifndef FUNCTION_scaleValues_DBL 166 /*! 167 * 168 * \brief Multiply input vector by \f$ 2^{scalefactor} \f$ 169 * \param len must be larger than 4 170 * \return void 171 * 172 */ 173 #define FUNCTION_scaleValues_DBL 174 SCALE_INLINE 175 void scaleValues(FIXP_DBL *vector, /*!< Vector */ 176 INT len, /*!< Length */ 177 INT scalefactor /*!< Scalefactor */ 178 ) { 179 INT i; 180 181 /* Return if scalefactor is Zero */ 182 if (scalefactor == 0) return; 183 184 if (scalefactor > 0) { 185 scalefactor = fixmin_I(scalefactor, (INT)DFRACT_BITS - 1); 186 for (i = len & 3; i--;) { 187 *(vector++) <<= scalefactor; 188 } 189 for (i = len >> 2; i--;) { 190 *(vector++) <<= scalefactor; 191 *(vector++) <<= scalefactor; 192 *(vector++) <<= scalefactor; 193 *(vector++) <<= scalefactor; 194 } 195 } else { 196 INT negScalefactor = fixmin_I(-scalefactor, (INT)DFRACT_BITS - 1); 197 for (i = len & 3; i--;) { 198 *(vector++) >>= negScalefactor; 199 } 200 for (i = len >> 2; i--;) { 201 *(vector++) >>= negScalefactor; 202 *(vector++) >>= negScalefactor; 203 *(vector++) >>= negScalefactor; 204 *(vector++) >>= negScalefactor; 205 } 206 } 207 } 208 #endif 209 210 #ifndef FUNCTION_scaleValuesSaturate_DBL 211 /*! 212 * 213 * \brief Multiply input vector by \f$ 2^{scalefactor} \f$ 214 * \param vector source/destination buffer 215 * \param len length of vector 216 * \param scalefactor amount of shifts to be applied 217 * \return void 218 * 219 */ 220 #define FUNCTION_scaleValuesSaturate_DBL 221 SCALE_INLINE 222 void scaleValuesSaturate(FIXP_DBL *vector, /*!< Vector */ 223 INT len, /*!< Length */ 224 INT scalefactor /*!< Scalefactor */ 225 ) { 226 INT i; 227 228 /* Return if scalefactor is Zero */ 229 if (scalefactor == 0) return; 230 231 scalefactor = fixmax_I(fixmin_I(scalefactor, (INT)DFRACT_BITS - 1), 232 (INT) - (DFRACT_BITS - 1)); 233 234 for (i = 0; i < len; i++) { 235 vector[i] = scaleValueSaturate(vector[i], scalefactor); 236 } 237 } 238 #endif /* FUNCTION_scaleValuesSaturate_DBL */ 239 240 #ifndef FUNCTION_scaleValuesSaturate_DBL_DBL 241 /*! 242 * 243 * \brief Multiply input vector by \f$ 2^{scalefactor} \f$ 244 * \param dst destination buffer 245 * \param src source buffer 246 * \param len length of vector 247 * \param scalefactor amount of shifts to be applied 248 * \return void 249 * 250 */ 251 #define FUNCTION_scaleValuesSaturate_DBL_DBL 252 SCALE_INLINE 253 void scaleValuesSaturate(FIXP_DBL *dst, /*!< Output */ 254 FIXP_DBL *src, /*!< Input */ 255 INT len, /*!< Length */ 256 INT scalefactor /*!< Scalefactor */ 257 ) { 258 INT i; 259 260 /* Return if scalefactor is Zero */ 261 if (scalefactor == 0) { 262 FDKmemmove(dst, src, len * sizeof(FIXP_DBL)); 263 return; 264 } 265 266 scalefactor = fixmax_I(fixmin_I(scalefactor, (INT)DFRACT_BITS - 1), 267 (INT) - (DFRACT_BITS - 1)); 268 269 for (i = 0; i < len; i++) { 270 dst[i] = scaleValueSaturate(src[i], scalefactor); 271 } 272 } 273 #endif /* FUNCTION_scaleValuesSaturate_DBL_DBL */ 274 275 #ifndef FUNCTION_scaleValuesSaturate_SGL_DBL 276 /*! 277 * 278 * \brief Multiply input vector by \f$ 2^{scalefactor} \f$ 279 * \param dst destination buffer (FIXP_SGL) 280 * \param src source buffer (FIXP_DBL) 281 * \param len length of vector 282 * \param scalefactor amount of shifts to be applied 283 * \return void 284 * 285 */ 286 #define FUNCTION_scaleValuesSaturate_SGL_DBL 287 SCALE_INLINE 288 void scaleValuesSaturate(FIXP_SGL *dst, /*!< Output */ 289 FIXP_DBL *src, /*!< Input */ 290 INT len, /*!< Length */ 291 INT scalefactor) /*!< Scalefactor */ 292 { 293 INT i; 294 scalefactor = fixmax_I(fixmin_I(scalefactor, (INT)DFRACT_BITS - 1), 295 (INT) - (DFRACT_BITS - 1)); 296 297 for (i = 0; i < len; i++) { 298 dst[i] = FX_DBL2FX_SGL(fAddSaturate(scaleValueSaturate(src[i], scalefactor), 299 (FIXP_DBL)0x8000)); 300 } 301 } 302 #endif /* FUNCTION_scaleValuesSaturate_SGL_DBL */ 303 304 #ifndef FUNCTION_scaleValuesSaturate_SGL 305 /*! 306 * 307 * \brief Multiply input vector by \f$ 2^{scalefactor} \f$ 308 * \param vector source/destination buffer 309 * \param len length of vector 310 * \param scalefactor amount of shifts to be applied 311 * \return void 312 * 313 */ 314 #define FUNCTION_scaleValuesSaturate_SGL 315 SCALE_INLINE 316 void scaleValuesSaturate(FIXP_SGL *vector, /*!< Vector */ 317 INT len, /*!< Length */ 318 INT scalefactor /*!< Scalefactor */ 319 ) { 320 INT i; 321 322 /* Return if scalefactor is Zero */ 323 if (scalefactor == 0) return; 324 325 scalefactor = fixmax_I(fixmin_I(scalefactor, (INT)DFRACT_BITS - 1), 326 (INT) - (DFRACT_BITS - 1)); 327 328 for (i = 0; i < len; i++) { 329 vector[i] = FX_DBL2FX_SGL( 330 scaleValueSaturate(FX_SGL2FX_DBL(vector[i]), scalefactor)); 331 } 332 } 333 #endif /* FUNCTION_scaleValuesSaturate_SGL */ 334 335 #ifndef FUNCTION_scaleValuesSaturate_SGL_SGL 336 /*! 337 * 338 * \brief Multiply input vector by \f$ 2^{scalefactor} \f$ 339 * \param dst destination buffer 340 * \param src source buffer 341 * \param len length of vector 342 * \param scalefactor amount of shifts to be applied 343 * \return void 344 * 345 */ 346 #define FUNCTION_scaleValuesSaturate_SGL_SGL 347 SCALE_INLINE 348 void scaleValuesSaturate(FIXP_SGL *dst, /*!< Output */ 349 FIXP_SGL *src, /*!< Input */ 350 INT len, /*!< Length */ 351 INT scalefactor /*!< Scalefactor */ 352 ) { 353 INT i; 354 355 /* Return if scalefactor is Zero */ 356 if (scalefactor == 0) { 357 FDKmemmove(dst, src, len * sizeof(FIXP_SGL)); 358 return; 359 } 360 361 scalefactor = fixmax_I(fixmin_I(scalefactor, (INT)DFRACT_BITS - 1), 362 (INT) - (DFRACT_BITS - 1)); 363 364 for (i = 0; i < len; i++) { 365 dst[i] = 366 FX_DBL2FX_SGL(scaleValueSaturate(FX_SGL2FX_DBL(src[i]), scalefactor)); 367 } 368 } 369 #endif /* FUNCTION_scaleValuesSaturate_SGL_SGL */ 370 371 #ifndef FUNCTION_scaleValues_DBLDBL 372 /*! 373 * 374 * \brief Multiply input vector src by \f$ 2^{scalefactor} \f$ 375 * and place result into dst 376 * \param dst detination buffer 377 * \param src source buffer 378 * \param len must be larger than 4 379 * \param scalefactor amount of left shifts to be applied 380 * \return void 381 * 382 */ 383 #define FUNCTION_scaleValues_DBLDBL 384 SCALE_INLINE 385 void scaleValues(FIXP_DBL *dst, /*!< dst Vector */ 386 const FIXP_DBL *src, /*!< src Vector */ 387 INT len, /*!< Length */ 388 INT scalefactor /*!< Scalefactor */ 389 ) { 390 INT i; 391 392 /* Return if scalefactor is Zero */ 393 if (scalefactor == 0) { 394 if (dst != src) FDKmemmove(dst, src, len * sizeof(FIXP_DBL)); 395 } else { 396 if (scalefactor > 0) { 397 scalefactor = fixmin_I(scalefactor, (INT)DFRACT_BITS - 1); 398 for (i = len & 3; i--;) { 399 *(dst++) = *(src++) << scalefactor; 400 } 401 for (i = len >> 2; i--;) { 402 *(dst++) = *(src++) << scalefactor; 403 *(dst++) = *(src++) << scalefactor; 404 *(dst++) = *(src++) << scalefactor; 405 *(dst++) = *(src++) << scalefactor; 406 } 407 } else { 408 INT negScalefactor = fixmin_I(-scalefactor, (INT)DFRACT_BITS - 1); 409 for (i = len & 3; i--;) { 410 *(dst++) = *(src++) >> negScalefactor; 411 } 412 for (i = len >> 2; i--;) { 413 *(dst++) = *(src++) >> negScalefactor; 414 *(dst++) = *(src++) >> negScalefactor; 415 *(dst++) = *(src++) >> negScalefactor; 416 *(dst++) = *(src++) >> negScalefactor; 417 } 418 } 419 } 420 } 421 #endif 422 423 #if (SAMPLE_BITS == 16) 424 #ifndef FUNCTION_scaleValues_PCMDBL 425 /*! 426 * 427 * \brief Multiply input vector src by \f$ 2^{scalefactor} \f$ 428 * and place result into dst 429 * \param dst detination buffer 430 * \param src source buffer 431 * \param len must be larger than 4 432 * \param scalefactor amount of left shifts to be applied 433 * \return void 434 * 435 */ 436 #define FUNCTION_scaleValues_PCMDBL 437 SCALE_INLINE 438 void scaleValues(FIXP_PCM *dst, /*!< dst Vector */ 439 const FIXP_DBL *src, /*!< src Vector */ 440 INT len, /*!< Length */ 441 INT scalefactor /*!< Scalefactor */ 442 ) { 443 INT i; 444 445 scalefactor -= DFRACT_BITS - SAMPLE_BITS; 446 447 /* Return if scalefactor is Zero */ 448 { 449 if (scalefactor > 0) { 450 scalefactor = fixmin_I(scalefactor, (INT)DFRACT_BITS - 1); 451 for (i = len & 3; i--;) { 452 *(dst++) = (FIXP_PCM)(*(src++) << scalefactor); 453 } 454 for (i = len >> 2; i--;) { 455 *(dst++) = (FIXP_PCM)(*(src++) << scalefactor); 456 *(dst++) = (FIXP_PCM)(*(src++) << scalefactor); 457 *(dst++) = (FIXP_PCM)(*(src++) << scalefactor); 458 *(dst++) = (FIXP_PCM)(*(src++) << scalefactor); 459 } 460 } else { 461 INT negScalefactor = fixmin_I(-scalefactor, (INT)DFRACT_BITS - 1); 462 for (i = len & 3; i--;) { 463 *(dst++) = (FIXP_PCM)(*(src++) >> negScalefactor); 464 } 465 for (i = len >> 2; i--;) { 466 *(dst++) = (FIXP_PCM)(*(src++) >> negScalefactor); 467 *(dst++) = (FIXP_PCM)(*(src++) >> negScalefactor); 468 *(dst++) = (FIXP_PCM)(*(src++) >> negScalefactor); 469 *(dst++) = (FIXP_PCM)(*(src++) >> negScalefactor); 470 } 471 } 472 } 473 } 474 #endif 475 #endif /* (SAMPLE_BITS == 16) */ 476 477 #ifndef FUNCTION_scaleValues_SGLSGL 478 /*! 479 * 480 * \brief Multiply input vector src by \f$ 2^{scalefactor} \f$ 481 * and place result into dst 482 * \param dst detination buffer 483 * \param src source buffer 484 * \param len must be larger than 4 485 * \param scalefactor amount of left shifts to be applied 486 * \return void 487 * 488 */ 489 #define FUNCTION_scaleValues_SGLSGL 490 SCALE_INLINE 491 void scaleValues(FIXP_SGL *dst, /*!< dst Vector */ 492 const FIXP_SGL *src, /*!< src Vector */ 493 INT len, /*!< Length */ 494 INT scalefactor /*!< Scalefactor */ 495 ) { 496 INT i; 497 498 /* Return if scalefactor is Zero */ 499 if (scalefactor == 0) { 500 if (dst != src) FDKmemmove(dst, src, len * sizeof(FIXP_DBL)); 501 } else { 502 if (scalefactor > 0) { 503 scalefactor = fixmin_I(scalefactor, (INT)DFRACT_BITS - 1); 504 for (i = len & 3; i--;) { 505 *(dst++) = *(src++) << scalefactor; 506 } 507 for (i = len >> 2; i--;) { 508 *(dst++) = *(src++) << scalefactor; 509 *(dst++) = *(src++) << scalefactor; 510 *(dst++) = *(src++) << scalefactor; 511 *(dst++) = *(src++) << scalefactor; 512 } 513 } else { 514 INT negScalefactor = fixmin_I(-scalefactor, (INT)DFRACT_BITS - 1); 515 for (i = len & 3; i--;) { 516 *(dst++) = *(src++) >> negScalefactor; 517 } 518 for (i = len >> 2; i--;) { 519 *(dst++) = *(src++) >> negScalefactor; 520 *(dst++) = *(src++) >> negScalefactor; 521 *(dst++) = *(src++) >> negScalefactor; 522 *(dst++) = *(src++) >> negScalefactor; 523 } 524 } 525 } 526 } 527 #endif 528 529 #ifndef FUNCTION_scaleValuesWithFactor_DBL 530 /*! 531 * 532 * \brief Multiply input vector by \f$ 2^{scalefactor} \f$ 533 * \param len must be larger than 4 534 * \return void 535 * 536 */ 537 #define FUNCTION_scaleValuesWithFactor_DBL 538 SCALE_INLINE 539 void scaleValuesWithFactor(FIXP_DBL *vector, FIXP_DBL factor, INT len, 540 INT scalefactor) { 541 INT i; 542 543 /* Compensate fMultDiv2 */ 544 scalefactor++; 545 546 if (scalefactor > 0) { 547 scalefactor = fixmin_I(scalefactor, (INT)DFRACT_BITS - 1); 548 for (i = len & 3; i--;) { 549 *vector = fMultDiv2(*vector, factor) << scalefactor; 550 vector++; 551 } 552 for (i = len >> 2; i--;) { 553 *vector = fMultDiv2(*vector, factor) << scalefactor; 554 vector++; 555 *vector = fMultDiv2(*vector, factor) << scalefactor; 556 vector++; 557 *vector = fMultDiv2(*vector, factor) << scalefactor; 558 vector++; 559 *vector = fMultDiv2(*vector, factor) << scalefactor; 560 vector++; 561 } 562 } else { 563 INT negScalefactor = fixmin_I(-scalefactor, (INT)DFRACT_BITS - 1); 564 for (i = len & 3; i--;) { 565 *vector = fMultDiv2(*vector, factor) >> negScalefactor; 566 vector++; 567 } 568 for (i = len >> 2; i--;) { 569 *vector = fMultDiv2(*vector, factor) >> negScalefactor; 570 vector++; 571 *vector = fMultDiv2(*vector, factor) >> negScalefactor; 572 vector++; 573 *vector = fMultDiv2(*vector, factor) >> negScalefactor; 574 vector++; 575 *vector = fMultDiv2(*vector, factor) >> negScalefactor; 576 vector++; 577 } 578 } 579 } 580 #endif /* FUNCTION_scaleValuesWithFactor_DBL */ 581 582 /******************************************* 583 584 IMPORTANT NOTE for usage of getScalefactor() 585 586 If the input array contains negative values too, then these functions may 587 sometimes return the actual maximum value minus 1, due to the nature of the 588 applied algorithm. So be careful with possible fractional -1 values that may 589 lead to overflows when being fPow2()'ed. 590 591 ********************************************/ 592 593 #ifndef FUNCTION_getScalefactorShort 594 /*! 595 * 596 * \brief Calculate max possible scale factor for input vector of shorts 597 * 598 * \return Maximum scale factor / possible left shift 599 * 600 */ 601 #define FUNCTION_getScalefactorShort 602 SCALE_INLINE 603 INT getScalefactorShort(const SHORT *vector, /*!< Pointer to input vector */ 604 INT len /*!< Length of input vector */ 605 ) { 606 INT i; 607 SHORT temp, maxVal = 0; 608 609 for (i = len; i != 0; i--) { 610 temp = (SHORT)(*vector++); 611 maxVal |= (temp ^ (temp >> (SHORT_BITS - 1))); 612 } 613 614 return fixmax_I((INT)0, (INT)(fixnormz_D((INT)maxVal) - (INT)1 - 615 (INT)(DFRACT_BITS - SHORT_BITS))); 616 } 617 #endif 618 619 #ifndef FUNCTION_getScalefactorPCM 620 /*! 621 * 622 * \brief Calculate max possible scale factor for input vector of shorts 623 * 624 * \return Maximum scale factor 625 * 626 */ 627 #define FUNCTION_getScalefactorPCM 628 SCALE_INLINE 629 INT getScalefactorPCM(const INT_PCM *vector, /*!< Pointer to input vector */ 630 INT len, /*!< Length of input vector */ 631 INT stride) { 632 INT i; 633 INT_PCM temp, maxVal = 0; 634 635 for (i = len; i != 0; i--) { 636 temp = (INT_PCM)(*vector); 637 vector += stride; 638 maxVal |= (temp ^ (temp >> ((sizeof(INT_PCM) * 8) - 1))); 639 } 640 return fixmax_I((INT)0, (INT)(fixnormz_D((INT)maxVal) - (INT)1 - 641 (INT)(DFRACT_BITS - SAMPLE_BITS))); 642 } 643 #endif 644 645 #ifndef FUNCTION_getScalefactorShort 646 /*! 647 * 648 * \brief Calculate max possible scale factor for input vector of shorts 649 * \param stride, item increment between vector members. 650 * \return Maximum scale factor 651 * 652 */ 653 #define FUNCTION_getScalefactorShort 654 SCALE_INLINE 655 INT getScalefactorShort(const SHORT *vector, /*!< Pointer to input vector */ 656 INT len, /*!< Length of input vector */ 657 INT stride) { 658 INT i; 659 SHORT temp, maxVal = 0; 660 661 for (i = len; i != 0; i--) { 662 temp = (SHORT)(*vector); 663 vector += stride; 664 maxVal |= (temp ^ (temp >> (SHORT_BITS - 1))); 665 } 666 667 return fixmax_I((INT)0, (INT)(fixnormz_D((INT)maxVal) - (INT)1 - 668 (INT)(DFRACT_BITS - SHORT_BITS))); 669 } 670 #endif 671 672 #ifndef FUNCTION_getScalefactor_DBL 673 /*! 674 * 675 * \brief Calculate max possible scale factor for input vector 676 * 677 * \return Maximum scale factor 678 * 679 * This function can constitute a significant amount of computational 680 * complexity - very much depending on the bitrate. Since it is a rather small 681 * function, effective assembler optimization might be possible. 682 * 683 * If all data is 0xFFFF.FFFF or 0x0000.0000 function returns 31 684 * Note: You can skip data normalization only if return value is 0 685 * 686 */ 687 #define FUNCTION_getScalefactor_DBL 688 SCALE_INLINE 689 INT getScalefactor(const FIXP_DBL *vector, /*!< Pointer to input vector */ 690 INT len) /*!< Length of input vector */ 691 { 692 INT i; 693 FIXP_DBL temp, maxVal = (FIXP_DBL)0; 694 695 for (i = len; i != 0; i--) { 696 temp = (LONG)(*vector++); 697 maxVal |= (FIXP_DBL)((LONG)temp ^ (LONG)(temp >> (DFRACT_BITS - 1))); 698 } 699 700 return fixmax_I((INT)0, (INT)(fixnormz_D(maxVal) - 1)); 701 } 702 #endif 703 704 #ifndef FUNCTION_getScalefactor_SGL 705 #define FUNCTION_getScalefactor_SGL 706 SCALE_INLINE 707 INT getScalefactor(const FIXP_SGL *vector, /*!< Pointer to input vector */ 708 INT len) /*!< Length of input vector */ 709 { 710 INT i; 711 SHORT temp, maxVal = (FIXP_SGL)0; 712 713 for (i = len; i != 0; i--) { 714 temp = (SHORT)(*vector++); 715 maxVal |= (temp ^ (temp >> (FRACT_BITS - 1))); 716 } 717 718 return fixmax_I((INT)0, (INT)(fixnormz_S((FIXP_SGL)maxVal)) - 1); 719 } 720 #endif 721
