1 2/* ----------------------------------------------------------------------------------------------------------- 3Software License for The Fraunhofer FDK AAC Codec Library for Android 4 5� Copyright 1995 - 2013 Fraunhofer-Gesellschaft zur F�rderung der angewandten Forschung e.V. 6 All rights reserved. 7 8 1. INTRODUCTION 9The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements 10the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio. 11This FDK AAC Codec software is intended to be used on a wide variety of Android devices. 12 13AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual 14audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by 15independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part 16of the MPEG specifications. 17 18Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer) 19may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners 20individually for the purpose of encoding or decoding bit streams in products that are compliant with 21the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license 22these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec 23software may already be covered under those patent licenses when it is used for those licensed purposes only. 24 25Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality, 26are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional 27applications information and documentation. 28 292. COPYRIGHT LICENSE 30 31Redistribution and use in source and binary forms, with or without modification, are permitted without 32payment of copyright license fees provided that you satisfy the following conditions: 33 34You must retain the complete text of this software license in redistributions of the FDK AAC Codec or 35your modifications thereto in source code form. 36 37You must retain the complete text of this software license in the documentation and/or other materials 38provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form. 39You must make available free of charge copies of the complete source code of the FDK AAC Codec and your 40modifications thereto to recipients of copies in binary form. 41 42The name of Fraunhofer may not be used to endorse or promote products derived from this library without 43prior written permission. 44 45You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec 46software or your modifications thereto. 47 48Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software 49and the date of any change. For modified versions of the FDK AAC Codec, the term 50"Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term 51"Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android." 52 533. NO PATENT LICENSE 54 55NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer, 56ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with 57respect to this software. 58 59You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized 60by appropriate patent licenses. 61 624. DISCLAIMER 63 64This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors 65"AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties 66of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 67CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages, 68including but not limited to procurement of substitute goods or services; loss of use, data, or profits, 69or business interruption, however caused and on any theory of liability, whether in contract, strict 70liability, or tort (including negligence), arising in any way out of the use of this software, even if 71advised of the possibility of such damage. 72 735. CONTACT INFORMATION 74 75Fraunhofer Institute for Integrated Circuits IIS 76Attention: Audio and Multimedia Departments - FDK AAC LL 77Am Wolfsmantel 33 7891058 Erlangen, Germany 79 80www.iis.fraunhofer.de/amm 81amm-info@iis.fraunhofer.de 82----------------------------------------------------------------------------------------------------------- */ 83 84/*! 85 \file 86 \brief Frequency scale calculation 87*/ 88 89#include "sbrdec_freq_sca.h" 90 91#include "transcendent.h" 92#include "sbr_rom.h" 93#include "env_extr.h" 94 95#include "genericStds.h" /* need log() for debug-code only */ 96 97#define MAX_OCTAVE 29 98#define MAX_SECOND_REGION 50 99 100 101static int numberOfBands(FIXP_SGL bpo_div16, int start, int stop, int warpFlag); 102static void CalcBands(UCHAR * diff, UCHAR start, UCHAR stop, UCHAR num_bands); 103static SBR_ERROR modifyBands(UCHAR max_band, UCHAR * diff, UCHAR length); 104static void cumSum(UCHAR start_value, UCHAR* diff, UCHAR length, UCHAR *start_adress); 105 106 107 108/*! 109 \brief Retrieve QMF-band where the SBR range starts 110 111 Convert startFreq which was read from the bitstream into a 112 QMF-channel number. 113 114 \return Number of start band 115*/ 116static UCHAR 117getStartBand(UINT fs, /*!< Output sampling frequency */ 118 UCHAR startFreq, /*!< Index to table of possible start bands */ 119 UINT headerDataFlags) /*!< Info to SBR mode */ 120{ 121 INT band; 122 UINT fsMapped; 123 124 fsMapped = fs; 125 126 switch (fsMapped) { 127 case 96000: 128 case 88200: 129 band = FDK_sbrDecoder_sbr_start_freq_88[startFreq]; 130 break; 131 case 64000: 132 band = FDK_sbrDecoder_sbr_start_freq_64[startFreq]; 133 break; 134 case 48000: 135 band = FDK_sbrDecoder_sbr_start_freq_48[startFreq]; 136 break; 137 case 44100: 138 band = FDK_sbrDecoder_sbr_start_freq_44[startFreq]; 139 break; 140 case 32000: 141 band = FDK_sbrDecoder_sbr_start_freq_32[startFreq]; 142 break; 143 case 24000: 144 band = FDK_sbrDecoder_sbr_start_freq_24[startFreq]; 145 break; 146 case 22050: 147 band = FDK_sbrDecoder_sbr_start_freq_22[startFreq]; 148 break; 149 case 16000: 150 band = FDK_sbrDecoder_sbr_start_freq_16[startFreq]; 151 break; 152 default: 153 band = 255; 154 } 155 156 return band; 157} 158 159 160/*! 161 \brief Retrieve QMF-band where the SBR range starts 162 163 Convert startFreq which was read from the bitstream into a 164 QMF-channel number. 165 166 \return Number of start band 167*/ 168static UCHAR 169getStopBand(UINT fs, /*!< Output sampling frequency */ 170 UCHAR stopFreq, /*!< Index to table of possible start bands */ 171 UINT headerDataFlags, /*!< Info to SBR mode */ 172 UCHAR k0) /*!< Start freq index */ 173{ 174 UCHAR k2; 175 176 if (stopFreq < 14) { 177 INT stopMin; 178 UCHAR diff_tot[MAX_OCTAVE + MAX_SECOND_REGION]; 179 UCHAR *diff0 = diff_tot; 180 UCHAR *diff1 = diff_tot+MAX_OCTAVE; 181 182 if (fs < 32000) { 183 stopMin = (((2*6000*2*(64)) / fs) + 1) >> 1; 184 } 185 else { 186 if (fs < 64000) { 187 stopMin = (((2*8000*2*(64)) / fs) + 1) >> 1; 188 } 189 else { 190 stopMin = (((2*10000*2*(64)) / fs) + 1) >> 1; 191 } 192 } 193 194 /* 195 Choose a stop band between k1 and 64 depending on stopFreq (0..13), 196 based on a logarithmic scale. 197 The vectors diff0 and diff1 are used temporarily here. 198 */ 199 CalcBands( diff0, stopMin, 64, 13); 200 shellsort( diff0, 13); 201 cumSum(stopMin, diff0, 13, diff1); 202 k2 = diff1[stopFreq]; 203 } 204 else if (stopFreq==14) 205 k2 = 2*k0; 206 else 207 k2 = 3*k0; 208 209 /* Limit to Nyquist */ 210 if (k2 > (64)) 211 k2 = (64); 212 213 214 /* Range checks */ 215 /* 1 <= difference <= 48; 1 <= fs <= 96000 */ 216 if ( ((k2 - k0) > MAX_FREQ_COEFFS) || (k2 <= k0) ) { 217 return 255; 218 } 219 220 if (headerDataFlags & (SBRDEC_SYNTAX_USAC|SBRDEC_SYNTAX_RSVD50)) { 221 /* 1 <= difference <= 35; 42000 <= fs <= 96000 */ 222 if ( (fs >= 42000) && ( (k2 - k0) > MAX_FREQ_COEFFS_FS44100 ) ) { 223 return 255; 224 } 225 /* 1 <= difference <= 32; 46009 <= fs <= 96000 */ 226 if ( (fs >= 46009) && ( (k2 - k0) > MAX_FREQ_COEFFS_FS48000 ) ) { 227 return 255; 228 } 229 } 230 else { 231 /* 1 <= difference <= 35; fs == 44100 */ 232 if ( (fs == 44100) && ( (k2 - k0) > MAX_FREQ_COEFFS_FS44100 ) ) { 233 return 255; 234 } 235 /* 1 <= difference <= 32; 48000 <= fs <= 96000 */ 236 if ( (fs >= 48000) && ( (k2 - k0) > MAX_FREQ_COEFFS_FS48000 ) ) { 237 return 255; 238 } 239 } 240 241 return k2; 242} 243 244 245/*! 246 \brief Generates master frequency tables 247 248 Frequency tables are calculated according to the selected domain 249 (linear/logarithmic) and granularity. 250 IEC 14496-3 4.6.18.3.2.1 251 252 \return errorCode, 0 if successful 253*/ 254SBR_ERROR 255sbrdecUpdateFreqScale(UCHAR * v_k_master, /*!< Master table to be created */ 256 UCHAR *numMaster, /*!< Number of entries in master table */ 257 UINT fs, /*!< SBR working sampling rate */ 258 HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Control data from bitstream */ 259 UINT flags) 260{ 261 FIXP_SGL bpo_div16; /* bands_per_octave divided by 16 */ 262 INT dk=0; 263 264 /* Internal variables */ 265 UCHAR k0, k2, i; 266 UCHAR num_bands0 = 0; 267 UCHAR num_bands1 = 0; 268 UCHAR diff_tot[MAX_OCTAVE + MAX_SECOND_REGION]; 269 UCHAR *diff0 = diff_tot; 270 UCHAR *diff1 = diff_tot+MAX_OCTAVE; 271 INT k2_achived; 272 INT k2_diff; 273 INT incr=0; 274 275 /* 276 Determine start band 277 */ 278 k0 = getStartBand(fs, hHeaderData->bs_data.startFreq, flags); 279 if (k0 == 255) { 280 return SBRDEC_UNSUPPORTED_CONFIG; 281 } 282 283 /* 284 Determine stop band 285 */ 286 k2 = getStopBand(fs, hHeaderData->bs_data.stopFreq, flags, k0); 287 if (k2 == 255) { 288 return SBRDEC_UNSUPPORTED_CONFIG; 289 } 290 291 if(hHeaderData->bs_data.freqScale>0) { /* Bark */ 292 INT k1; 293 294 if(hHeaderData->bs_data.freqScale==1) { 295 bpo_div16 = FL2FXCONST_SGL(12.0f/16.0f); 296 } 297 else if(hHeaderData->bs_data.freqScale==2) { 298 bpo_div16 = FL2FXCONST_SGL(10.0f/16.0f); 299 } 300 else { 301 bpo_div16 = FL2FXCONST_SGL(8.0f/16.0f); 302 } 303 304 305 if( 1000 * k2 > 2245 * k0 ) { /* Two or more regions */ 306 k1 = 2*k0; 307 308 num_bands0 = numberOfBands(bpo_div16, k0, k1, 0); 309 num_bands1 = numberOfBands(bpo_div16, k1, k2, hHeaderData->bs_data.alterScale ); 310 if ( num_bands0 < 1) { 311 return SBRDEC_UNSUPPORTED_CONFIG; 312 } 313 if ( num_bands1 < 1 ) { 314 return SBRDEC_UNSUPPORTED_CONFIG; 315 } 316 317 CalcBands(diff0, k0, k1, num_bands0); 318 shellsort( diff0, num_bands0); 319 if (diff0[0] == 0) { 320#ifdef DEBUG_TOOLS 321#endif 322 return SBRDEC_UNSUPPORTED_CONFIG; 323 } 324 325 cumSum(k0, diff0, num_bands0, v_k_master); 326 327 CalcBands(diff1, k1, k2, num_bands1); 328 shellsort( diff1, num_bands1); 329 if(diff0[num_bands0-1] > diff1[0]) { 330 SBR_ERROR err; 331 332 err = modifyBands(diff0[num_bands0-1],diff1, num_bands1); 333 if (err) 334 return SBRDEC_UNSUPPORTED_CONFIG; 335 } 336 337 /* Add 2nd region */ 338 cumSum(k1, diff1, num_bands1, &v_k_master[num_bands0]); 339 *numMaster = num_bands0 + num_bands1; /* Output nr of bands */ 340 341 } 342 else { /* Only one region */ 343 k1=k2; 344 345 num_bands0 = numberOfBands(bpo_div16, k0, k1, 0); 346 if ( num_bands0 < 1) { 347 return SBRDEC_UNSUPPORTED_CONFIG; 348 } 349 CalcBands(diff0, k0, k1, num_bands0); 350 shellsort(diff0, num_bands0); 351 if (diff0[0] == 0) { 352#ifdef DEBUG_TOOLS 353#endif 354 return SBRDEC_UNSUPPORTED_CONFIG; 355 } 356 357 cumSum(k0, diff0, num_bands0, v_k_master); 358 *numMaster = num_bands0; /* Output nr of bands */ 359 360 } 361 } 362 else { /* Linear mode */ 363 if (hHeaderData->bs_data.alterScale==0) { 364 dk = 1; 365 /* FLOOR to get to few number of bands (next lower even number) */ 366 num_bands0 = (k2 - k0) & 254; 367 } else { 368 dk = 2; 369 num_bands0 = ( ((k2 - k0) >> 1) + 1 ) & 254; /* ROUND to the closest fit */ 370 } 371 372 if (num_bands0 < 1) { 373 return SBRDEC_UNSUPPORTED_CONFIG; 374 /* We must return already here because 'i' can become negative below. */ 375 } 376 377 k2_achived = k0 + num_bands0*dk; 378 k2_diff = k2 - k2_achived; 379 380 for(i=0;i<num_bands0;i++) 381 diff_tot[i] = dk; 382 383 /* If linear scale wasn't achieved */ 384 /* and we got too wide SBR area */ 385 if (k2_diff < 0) { 386 incr = 1; 387 i = 0; 388 } 389 390 /* If linear scale wasn't achieved */ 391 /* and we got too small SBR area */ 392 if (k2_diff > 0) { 393 incr = -1; 394 i = num_bands0-1; 395 } 396 397 /* Adjust diff vector to get sepc. SBR range */ 398 while (k2_diff != 0) { 399 diff_tot[i] = diff_tot[i] - incr; 400 i = i + incr; 401 k2_diff = k2_diff + incr; 402 } 403 404 cumSum(k0, diff_tot, num_bands0, v_k_master);/* cumsum */ 405 *numMaster = num_bands0; /* Output nr of bands */ 406 } 407 408 if (*numMaster < 1) { 409 return SBRDEC_UNSUPPORTED_CONFIG; 410 } 411 412 413 /* 414 Print out the calculated table 415 */ 416 417 return SBRDEC_OK; 418} 419 420 421/*! 422 \brief Calculate frequency ratio of one SBR band 423 424 All SBR bands should span a constant frequency range in the logarithmic 425 domain. This function calculates the ratio of any SBR band's upper and lower 426 frequency. 427 428 \return num_band-th root of k_start/k_stop 429*/ 430static FIXP_SGL calcFactorPerBand(int k_start, int k_stop, int num_bands) 431{ 432/* Scaled bandfactor and step 1 bit right to avoid overflow 433 * use double data type */ 434 FIXP_DBL bandfactor = FL2FXCONST_DBL(0.25f); /* Start value */ 435 FIXP_DBL step = FL2FXCONST_DBL(0.125f); /* Initial increment for factor */ 436 437 int direction = 1; 438 439/* Because saturation can't be done in INT IIS, 440 * changed start and stop data type from FIXP_SGL to FIXP_DBL */ 441 FIXP_DBL start = k_start << (DFRACT_BITS-8); 442 FIXP_DBL stop = k_stop << (DFRACT_BITS-8); 443 444 FIXP_DBL temp; 445 446 int j, i=0; 447 448 while ( step > FL2FXCONST_DBL(0.0f)) { 449 i++; 450 temp = stop; 451 452 /* Calculate temp^num_bands: */ 453 for (j=0; j<num_bands; j++) 454 //temp = fMult(temp,bandfactor); 455 temp = fMultDiv2(temp,bandfactor)<<2; 456 457 if (temp<start) { /* Factor too strong, make it weaker */ 458 if (direction == 0) 459 /* Halfen step. Right shift is not done as fract because otherwise the 460 lowest bit cannot be cleared due to rounding */ 461 step = (FIXP_DBL)((LONG)step >> 1); 462 direction = 1; 463 bandfactor = bandfactor + step; 464 } 465 else { /* Factor is too weak: make it stronger */ 466 if (direction == 1) 467 step = (FIXP_DBL)((LONG)step >> 1); 468 direction = 0; 469 bandfactor = bandfactor - step; 470 } 471 472 if (i>100) { 473 step = FL2FXCONST_DBL(0.0f); 474 } 475 } 476 return FX_DBL2FX_SGL(bandfactor<<1); 477} 478 479 480/*! 481 \brief Calculate number of SBR bands between start and stop band 482 483 Given the number of bands per octave, this function calculates how many 484 bands fit in the given frequency range. 485 When the warpFlag is set, the 'band density' is decreased by a factor 486 of 1/1.3 487 488 \return number of bands 489*/ 490static int 491numberOfBands(FIXP_SGL bpo_div16, /*!< Input: number of bands per octave divided by 16 */ 492 int start, /*!< First QMF band of SBR frequency range */ 493 int stop, /*!< Last QMF band of SBR frequency range + 1 */ 494 int warpFlag) /*!< Stretching flag */ 495{ 496 FIXP_SGL num_bands_div128; 497 int num_bands; 498 499 num_bands_div128 = FX_DBL2FX_SGL(fMult(FDK_getNumOctavesDiv8(start,stop),bpo_div16)); 500 501 if (warpFlag) { 502 /* Apply the warp factor of 1.3 to get wider bands. We use a value 503 of 32768/25200 instead of the exact value to avoid critical cases 504 of rounding. 505 */ 506 num_bands_div128 = FX_DBL2FX_SGL(fMult(num_bands_div128, FL2FXCONST_SGL(25200.0/32768.0))); 507 } 508 509 /* add scaled 1 for rounding to even numbers: */ 510 num_bands_div128 = num_bands_div128 + FL2FXCONST_SGL( 1.0f/128.0f ); 511 /* scale back to right aligned integer and double the value: */ 512 num_bands = 2 * ((LONG)num_bands_div128 >> (FRACT_BITS - 7)); 513 514 return(num_bands); 515} 516 517 518/*! 519 \brief Calculate width of SBR bands 520 521 Given the desired number of bands within the SBR frequency range, 522 this function calculates the width of each SBR band in QMF channels. 523 The bands get wider from start to stop (bark scale). 524*/ 525static void 526CalcBands(UCHAR * diff, /*!< Vector of widths to be calculated */ 527 UCHAR start, /*!< Lower end of subband range */ 528 UCHAR stop, /*!< Upper end of subband range */ 529 UCHAR num_bands) /*!< Desired number of bands */ 530{ 531 int i; 532 int previous; 533 int current; 534 FIXP_SGL exact, temp; 535 FIXP_SGL bandfactor = calcFactorPerBand(start, stop, num_bands); 536 537 previous = stop; /* Start with highest QMF channel */ 538 exact = (FIXP_SGL)(stop << (FRACT_BITS-8)); /* Shift left to gain some accuracy */ 539 540 for(i=num_bands-1; i>=0; i--) { 541 /* Calculate border of next lower sbr band */ 542 exact = FX_DBL2FX_SGL(fMult(exact,bandfactor)); 543 544 /* Add scaled 0.5 for rounding: 545 We use a value 128/256 instead of 0.5 to avoid some critical cases of rounding. */ 546 temp = exact + FL2FXCONST_SGL(128.0/32768.0); 547 548 /* scale back to right alinged integer: */ 549 current = (LONG)temp >> (FRACT_BITS-8); 550 551 /* Save width of band i */ 552 diff[i] = previous - current; 553 previous = current; 554 } 555} 556 557 558/*! 559 \brief Calculate cumulated sum vector from delta vector 560*/ 561static void 562cumSum(UCHAR start_value, UCHAR* diff, UCHAR length, UCHAR *start_adress) 563{ 564 int i; 565 start_adress[0]=start_value; 566 for(i=1; i<=length; i++) 567 start_adress[i] = start_adress[i-1] + diff[i-1]; 568} 569 570 571/*! 572 \brief Adapt width of frequency bands in the second region 573 574 If SBR spans more than 2 octaves, the upper part of a bark-frequency-scale 575 is calculated separately. This function tries to avoid that the second region 576 starts with a band smaller than the highest band of the first region. 577*/ 578static SBR_ERROR 579modifyBands(UCHAR max_band_previous, UCHAR * diff, UCHAR length) 580{ 581 int change = max_band_previous - diff[0]; 582 583 /* Limit the change so that the last band cannot get narrower than the first one */ 584 if ( change > (diff[length-1]-diff[0])>>1 ) 585 change = (diff[length-1]-diff[0])>>1; 586 587 diff[0] += change; 588 diff[length-1] -= change; 589 shellsort(diff, length); 590 591 return SBRDEC_OK; 592} 593 594 595/*! 596 \brief Update high resolution frequency band table 597*/ 598static void 599sbrdecUpdateHiRes(UCHAR * h_hires, 600 UCHAR * num_hires, 601 UCHAR * v_k_master, 602 UCHAR num_bands, 603 UCHAR xover_band) 604{ 605 UCHAR i; 606 607 *num_hires = num_bands-xover_band; 608 609 for(i=xover_band; i<=num_bands; i++) { 610 h_hires[i-xover_band] = v_k_master[i]; 611 } 612} 613 614 615/*! 616 \brief Build low resolution table out of high resolution table 617*/ 618static void 619sbrdecUpdateLoRes(UCHAR * h_lores, 620 UCHAR * num_lores, 621 UCHAR * h_hires, 622 UCHAR num_hires) 623{ 624 UCHAR i; 625 626 if( (num_hires & 1) == 0) { 627 /* If even number of hires bands */ 628 *num_lores = num_hires >> 1; 629 /* Use every second lores=hires[0,2,4...] */ 630 for(i=0; i<=*num_lores; i++) 631 h_lores[i] = h_hires[i*2]; 632 } 633 else { 634 /* Odd number of hires, which means xover is odd */ 635 *num_lores = (num_hires+1) >> 1; 636 /* Use lores=hires[0,1,3,5 ...] */ 637 h_lores[0] = h_hires[0]; 638 for(i=1; i<=*num_lores; i++) { 639 h_lores[i] = h_hires[i*2-1]; 640 } 641 } 642} 643 644 645/*! 646 \brief Derive a low-resolution frequency-table from the master frequency table 647*/ 648void 649sbrdecDownSampleLoRes(UCHAR *v_result, 650 UCHAR num_result, 651 UCHAR *freqBandTableRef, 652 UCHAR num_Ref) 653{ 654 int step; 655 int i,j; 656 int org_length,result_length; 657 int v_index[MAX_FREQ_COEFFS>>1]; 658 659 /* init */ 660 org_length = num_Ref; 661 result_length = num_result; 662 663 v_index[0] = 0; /* Always use left border */ 664 i=0; 665 while(org_length > 0) { 666 /* Create downsample vector */ 667 i++; 668 step = org_length / result_length; 669 org_length = org_length - step; 670 result_length--; 671 v_index[i] = v_index[i-1] + step; 672 } 673 674 for(j=0;j<=i;j++) { 675 /* Use downsample vector to index LoResolution vector */ 676 v_result[j]=freqBandTableRef[v_index[j]]; 677 } 678 679} 680 681 682/*! 683 \brief Sorting routine 684*/ 685void shellsort(UCHAR *in, UCHAR n) 686{ 687 688 int i, j, v, w; 689 int inc = 1; 690 691 do 692 inc = 3 * inc + 1; 693 while (inc <= n); 694 695 do { 696 inc = inc / 3; 697 for (i = inc; i < n; i++) { 698 v = in[i]; 699 j = i; 700 while ((w=in[j-inc]) > v) { 701 in[j] = w; 702 j -= inc; 703 if (j < inc) 704 break; 705 } 706 in[j] = v; 707 } 708 } while (inc > 1); 709 710} 711 712 713 714/*! 715 \brief Reset frequency band tables 716 \return errorCode, 0 if successful 717*/ 718SBR_ERROR 719resetFreqBandTables(HANDLE_SBR_HEADER_DATA hHeaderData, const UINT flags) 720{ 721 SBR_ERROR err = SBRDEC_OK; 722 int k2,kx, lsb, usb; 723 int intTemp; 724 UCHAR nBandsLo, nBandsHi; 725 HANDLE_FREQ_BAND_DATA hFreq = &hHeaderData->freqBandData; 726 727 /* Calculate master frequency function */ 728 err = sbrdecUpdateFreqScale(hFreq->v_k_master, 729 &hFreq->numMaster, 730 hHeaderData->sbrProcSmplRate, 731 hHeaderData, 732 flags); 733 734 if ( err || (hHeaderData->bs_info.xover_band > hFreq->numMaster) ) { 735 return SBRDEC_UNSUPPORTED_CONFIG; 736 } 737 738 /* Derive Hiresolution from master frequency function */ 739 sbrdecUpdateHiRes(hFreq->freqBandTable[1], &nBandsHi, hFreq->v_k_master, hFreq->numMaster, hHeaderData->bs_info.xover_band ); 740 /* Derive Loresolution from Hiresolution */ 741 sbrdecUpdateLoRes(hFreq->freqBandTable[0], &nBandsLo, hFreq->freqBandTable[1], nBandsHi); 742 743 744 hFreq->nSfb[0] = nBandsLo; 745 hFreq->nSfb[1] = nBandsHi; 746 747 /* Check index to freqBandTable[0] */ 748 if ( !(nBandsLo > 0) || (nBandsLo > (MAX_FREQ_COEFFS>>1)) ) { 749 return SBRDEC_UNSUPPORTED_CONFIG; 750 } 751 752 lsb = hFreq->freqBandTable[0][0]; 753 usb = hFreq->freqBandTable[0][nBandsLo]; 754 755 /* Additional check for lsb */ 756 if ( (lsb > (32)) || (lsb >= usb) ) { 757 return SBRDEC_UNSUPPORTED_CONFIG; 758 } 759 760 761 /* Calculate number of noise bands */ 762 763 k2 = hFreq->freqBandTable[1][nBandsHi]; 764 kx = hFreq->freqBandTable[1][0]; 765 766 if (hHeaderData->bs_data.noise_bands == 0) 767 { 768 hFreq->nNfb = 1; 769 } 770 else /* Calculate no of noise bands 1,2 or 3 bands/octave */ 771 { 772 /* Fetch number of octaves divided by 32 */ 773 intTemp = (LONG)FDK_getNumOctavesDiv8(kx,k2) >> 2; 774 775 /* Integer-Multiplication with number of bands: */ 776 intTemp = intTemp * hHeaderData->bs_data.noise_bands; 777 778 /* Add scaled 0.5 for rounding: */ 779 intTemp = intTemp + (LONG)FL2FXCONST_SGL(0.5f/32.0f); 780 781 /* Convert to right-aligned integer: */ 782 intTemp = intTemp >> (FRACT_BITS - 1 /*sign*/ - 5 /* rescale */); 783 784 /* Compare with float calculation */ 785 FDK_ASSERT( intTemp == (int)((hHeaderData->bs_data.noise_bands * FDKlog( (float)k2/kx) / (float)(FDKlog(2.0)))+0.5) ); 786 787 if( intTemp==0) 788 intTemp=1; 789 790 hFreq->nNfb = intTemp; 791 } 792 793 hFreq->nInvfBands = hFreq->nNfb; 794 795 if( hFreq->nNfb > MAX_NOISE_COEFFS ) { 796 return SBRDEC_UNSUPPORTED_CONFIG; 797 } 798 799 /* Get noise bands */ 800 sbrdecDownSampleLoRes(hFreq->freqBandTableNoise, 801 hFreq->nNfb, 802 hFreq->freqBandTable[0], 803 nBandsLo); 804 805 806 807 808 hFreq->lowSubband = lsb; 809 hFreq->highSubband = usb; 810 811 return SBRDEC_OK; 812} 813