1 /* -----------------------------------------------------------------------------
2 Software License for The Fraunhofer FDK AAC Codec Library for Android
3
4 © Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Förderung 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@iis.fraunhofer.de
93 ----------------------------------------------------------------------------- */
94
95 /**************************** SBR decoder library ******************************
96
97 Author(s):
98
99 Description:
100
101 *******************************************************************************/
102
103 /*!
104 \file
105 \brief Frequency scale calculation
106 */
107
108 #include "sbrdec_freq_sca.h"
109
110 #include "transcendent.h"
111 #include "sbr_rom.h"
112 #include "env_extr.h"
113
114 #include "genericStds.h" /* need log() for debug-code only */
115
116 #define MAX_OCTAVE 29
117 #define MAX_SECOND_REGION 50
118
119 static int numberOfBands(FIXP_SGL bpo_div16, int start, int stop, int warpFlag);
120 static void CalcBands(UCHAR *diff, UCHAR start, UCHAR stop, UCHAR num_bands);
121 static SBR_ERROR modifyBands(UCHAR max_band, UCHAR *diff, UCHAR length);
122 static void cumSum(UCHAR start_value, UCHAR *diff, UCHAR length,
123 UCHAR *start_adress);
124
125 /*!
126 \brief Retrieve QMF-band where the SBR range starts
127
128 Convert startFreq which was read from the bitstream into a
129 QMF-channel number.
130
131 \return Number of start band
132 */
getStartBand(UINT fs,UCHAR startFreq,UINT headerDataFlags)133 static UCHAR getStartBand(
134 UINT fs, /*!< Output sampling frequency */
135 UCHAR startFreq, /*!< Index to table of possible start bands */
136 UINT headerDataFlags) /*!< Info to SBR mode */
137 {
138 INT band;
139 UINT fsMapped = fs;
140 SBR_RATE rate = DUAL;
141
142 if (headerDataFlags & (SBRDEC_SYNTAX_USAC | SBRDEC_SYNTAX_RSVD50)) {
143 if (headerDataFlags & SBRDEC_QUAD_RATE) {
144 rate = QUAD;
145 }
146 fsMapped = sbrdec_mapToStdSampleRate(fs, 1);
147 }
148
149 FDK_ASSERT(2 * (rate + 1) <= (4));
150
151 switch (fsMapped) {
152 case 192000:
153 band = FDK_sbrDecoder_sbr_start_freq_192[startFreq];
154 break;
155 case 176400:
156 band = FDK_sbrDecoder_sbr_start_freq_176[startFreq];
157 break;
158 case 128000:
159 band = FDK_sbrDecoder_sbr_start_freq_128[startFreq];
160 break;
161 case 96000:
162 case 88200:
163 band = FDK_sbrDecoder_sbr_start_freq_88[rate][startFreq];
164 break;
165 case 64000:
166 band = FDK_sbrDecoder_sbr_start_freq_64[rate][startFreq];
167 break;
168 case 48000:
169 band = FDK_sbrDecoder_sbr_start_freq_48[rate][startFreq];
170 break;
171 case 44100:
172 band = FDK_sbrDecoder_sbr_start_freq_44[rate][startFreq];
173 break;
174 case 40000:
175 band = FDK_sbrDecoder_sbr_start_freq_40[rate][startFreq];
176 break;
177 case 32000:
178 band = FDK_sbrDecoder_sbr_start_freq_32[rate][startFreq];
179 break;
180 case 24000:
181 band = FDK_sbrDecoder_sbr_start_freq_24[rate][startFreq];
182 break;
183 case 22050:
184 band = FDK_sbrDecoder_sbr_start_freq_22[rate][startFreq];
185 break;
186 case 16000:
187 band = FDK_sbrDecoder_sbr_start_freq_16[rate][startFreq];
188 break;
189 default:
190 band = 255;
191 }
192
193 return band;
194 }
195
196 /*!
197 \brief Retrieve QMF-band where the SBR range starts
198
199 Convert startFreq which was read from the bitstream into a
200 QMF-channel number.
201
202 \return Number of start band
203 */
getStopBand(UINT fs,UCHAR stopFreq,UINT headerDataFlags,UCHAR k0)204 static UCHAR getStopBand(
205 UINT fs, /*!< Output sampling frequency */
206 UCHAR stopFreq, /*!< Index to table of possible start bands */
207 UINT headerDataFlags, /*!< Info to SBR mode */
208 UCHAR k0) /*!< Start freq index */
209 {
210 UCHAR k2;
211
212 if (stopFreq < 14) {
213 INT stopMin;
214 INT num = 2 * (64);
215 UCHAR diff_tot[MAX_OCTAVE + MAX_SECOND_REGION];
216 UCHAR *diff0 = diff_tot;
217 UCHAR *diff1 = diff_tot + MAX_OCTAVE;
218
219 if (headerDataFlags & SBRDEC_QUAD_RATE) {
220 num >>= 1;
221 }
222
223 if (fs < 32000) {
224 stopMin = (((2 * 6000 * num) / fs) + 1) >> 1;
225 } else {
226 if (fs < 64000) {
227 stopMin = (((2 * 8000 * num) / fs) + 1) >> 1;
228 } else {
229 stopMin = (((2 * 10000 * num) / fs) + 1) >> 1;
230 }
231 }
232
233 /*
234 Choose a stop band between k1 and 64 depending on stopFreq (0..13),
235 based on a logarithmic scale.
236 The vectors diff0 and diff1 are used temporarily here.
237 */
238 CalcBands(diff0, stopMin, 64, 13);
239 shellsort(diff0, 13);
240 cumSum(stopMin, diff0, 13, diff1);
241 k2 = diff1[stopFreq];
242 } else if (stopFreq == 14)
243 k2 = 2 * k0;
244 else
245 k2 = 3 * k0;
246
247 /* Limit to Nyquist */
248 if (k2 > (64)) k2 = (64);
249
250 /* Range checks */
251 /* 1 <= difference <= 48; 1 <= fs <= 96000 */
252 {
253 UCHAR max_freq_coeffs = (headerDataFlags & SBRDEC_QUAD_RATE)
254 ? MAX_FREQ_COEFFS_QUAD_RATE
255 : MAX_FREQ_COEFFS;
256 if (((k2 - k0) > max_freq_coeffs) || (k2 <= k0)) {
257 return 255;
258 }
259 }
260
261 if (headerDataFlags & SBRDEC_QUAD_RATE) {
262 return k2; /* skip other checks: (k2 - k0) must be <=
263 MAX_FREQ_COEFFS_QUAD_RATE for all fs */
264 }
265 if (headerDataFlags & (SBRDEC_SYNTAX_USAC | SBRDEC_SYNTAX_RSVD50)) {
266 /* 1 <= difference <= 35; 42000 <= fs <= 96000 */
267 if ((fs >= 42000) && ((k2 - k0) > MAX_FREQ_COEFFS_FS44100)) {
268 return 255;
269 }
270 /* 1 <= difference <= 32; 46009 <= fs <= 96000 */
271 if ((fs >= 46009) && ((k2 - k0) > MAX_FREQ_COEFFS_FS48000)) {
272 return 255;
273 }
274 } else {
275 /* 1 <= difference <= 35; fs == 44100 */
276 if ((fs == 44100) && ((k2 - k0) > MAX_FREQ_COEFFS_FS44100)) {
277 return 255;
278 }
279 /* 1 <= difference <= 32; 48000 <= fs <= 96000 */
280 if ((fs >= 48000) && ((k2 - k0) > MAX_FREQ_COEFFS_FS48000)) {
281 return 255;
282 }
283 }
284
285 return k2;
286 }
287
288 /*!
289 \brief Generates master frequency tables
290
291 Frequency tables are calculated according to the selected domain
292 (linear/logarithmic) and granularity.
293 IEC 14496-3 4.6.18.3.2.1
294
295 \return errorCode, 0 if successful
296 */
297 SBR_ERROR
sbrdecUpdateFreqScale(UCHAR * v_k_master,UCHAR * numMaster,UINT fs,HANDLE_SBR_HEADER_DATA hHeaderData,UINT flags)298 sbrdecUpdateFreqScale(
299 UCHAR *v_k_master, /*!< Master table to be created */
300 UCHAR *numMaster, /*!< Number of entries in master table */
301 UINT fs, /*!< SBR working sampling rate */
302 HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Control data from bitstream */
303 UINT flags) {
304 FIXP_SGL bpo_div16; /* bands_per_octave divided by 16 */
305 INT dk = 0;
306
307 /* Internal variables */
308 UCHAR k0, k2, i;
309 UCHAR num_bands0 = 0;
310 UCHAR num_bands1 = 0;
311 UCHAR diff_tot[MAX_OCTAVE + MAX_SECOND_REGION];
312 UCHAR *diff0 = diff_tot;
313 UCHAR *diff1 = diff_tot + MAX_OCTAVE;
314 INT k2_achived;
315 INT k2_diff;
316 INT incr = 0;
317
318 /*
319 Determine start band
320 */
321 if (flags & SBRDEC_QUAD_RATE) {
322 fs >>= 1;
323 }
324
325 k0 = getStartBand(fs, hHeaderData->bs_data.startFreq, flags);
326 if (k0 == 255) {
327 return SBRDEC_UNSUPPORTED_CONFIG;
328 }
329
330 /*
331 Determine stop band
332 */
333 k2 = getStopBand(fs, hHeaderData->bs_data.stopFreq, flags, k0);
334 if (k2 == 255) {
335 return SBRDEC_UNSUPPORTED_CONFIG;
336 }
337
338 if (hHeaderData->bs_data.freqScale > 0) { /* Bark */
339 INT k1;
340
341 if (hHeaderData->bs_data.freqScale == 1) {
342 bpo_div16 = FL2FXCONST_SGL(12.0f / 16.0f);
343 } else if (hHeaderData->bs_data.freqScale == 2) {
344 bpo_div16 = FL2FXCONST_SGL(10.0f / 16.0f);
345 } else {
346 bpo_div16 = FL2FXCONST_SGL(8.0f / 16.0f);
347 }
348
349 /* Ref: ISO/IEC 23003-3, Figure 12 - Flowchart calculation of fMaster for
350 * 4:1 system when bs_freq_scale > 0 */
351 if (flags & SBRDEC_QUAD_RATE) {
352 if ((SHORT)k0 < (SHORT)(bpo_div16 >> ((FRACT_BITS - 1) - 4))) {
353 bpo_div16 = (FIXP_SGL)(k0 & (UCHAR)0xfe)
354 << ((FRACT_BITS - 1) - 4); /* bpo_div16 = floor(k0/2)*2 */
355 }
356 }
357
358 if (1000 * k2 > 2245 * k0) { /* Two or more regions */
359 k1 = 2 * k0;
360
361 num_bands0 = numberOfBands(bpo_div16, k0, k1, 0);
362 num_bands1 =
363 numberOfBands(bpo_div16, k1, k2, hHeaderData->bs_data.alterScale);
364 if (num_bands0 < 1) {
365 return SBRDEC_UNSUPPORTED_CONFIG;
366 }
367 if (num_bands1 < 1) {
368 return SBRDEC_UNSUPPORTED_CONFIG;
369 }
370
371 CalcBands(diff0, k0, k1, num_bands0);
372 shellsort(diff0, num_bands0);
373 if (diff0[0] == 0) {
374 return SBRDEC_UNSUPPORTED_CONFIG;
375 }
376
377 cumSum(k0, diff0, num_bands0, v_k_master);
378
379 CalcBands(diff1, k1, k2, num_bands1);
380 shellsort(diff1, num_bands1);
381 if (diff0[num_bands0 - 1] > diff1[0]) {
382 SBR_ERROR err;
383
384 err = modifyBands(diff0[num_bands0 - 1], diff1, num_bands1);
385 if (err) return SBRDEC_UNSUPPORTED_CONFIG;
386 }
387
388 /* Add 2nd region */
389 cumSum(k1, diff1, num_bands1, &v_k_master[num_bands0]);
390 *numMaster = num_bands0 + num_bands1; /* Output nr of bands */
391
392 } else { /* Only one region */
393 k1 = k2;
394
395 num_bands0 = numberOfBands(bpo_div16, k0, k1, 0);
396 if (num_bands0 < 1) {
397 return SBRDEC_UNSUPPORTED_CONFIG;
398 }
399 CalcBands(diff0, k0, k1, num_bands0);
400 shellsort(diff0, num_bands0);
401 if (diff0[0] == 0) {
402 return SBRDEC_UNSUPPORTED_CONFIG;
403 }
404
405 cumSum(k0, diff0, num_bands0, v_k_master);
406 *numMaster = num_bands0; /* Output nr of bands */
407 }
408 } else { /* Linear mode */
409 if (hHeaderData->bs_data.alterScale == 0) {
410 dk = 1;
411 /* FLOOR to get to few number of bands (next lower even number) */
412 num_bands0 = (k2 - k0) & 254;
413 } else {
414 dk = 2;
415 num_bands0 = (((k2 - k0) >> 1) + 1) & 254; /* ROUND to the closest fit */
416 }
417
418 if (num_bands0 < 1) {
419 return SBRDEC_UNSUPPORTED_CONFIG;
420 /* We must return already here because 'i' can become negative below. */
421 }
422
423 k2_achived = k0 + num_bands0 * dk;
424 k2_diff = k2 - k2_achived;
425
426 for (i = 0; i < num_bands0; i++) diff_tot[i] = dk;
427
428 /* If linear scale wasn't achieved */
429 /* and we got too wide SBR area */
430 if (k2_diff < 0) {
431 incr = 1;
432 i = 0;
433 }
434
435 /* If linear scale wasn't achieved */
436 /* and we got too small SBR area */
437 if (k2_diff > 0) {
438 incr = -1;
439 i = num_bands0 - 1;
440 }
441
442 /* Adjust diff vector to get sepc. SBR range */
443 while (k2_diff != 0) {
444 diff_tot[i] = diff_tot[i] - incr;
445 i = i + incr;
446 k2_diff = k2_diff + incr;
447 }
448
449 cumSum(k0, diff_tot, num_bands0, v_k_master); /* cumsum */
450 *numMaster = num_bands0; /* Output nr of bands */
451 }
452
453 if (*numMaster < 1) {
454 return SBRDEC_UNSUPPORTED_CONFIG;
455 }
456
457 /* Ref: ISO/IEC 23003-3 Cor.3, "In 7.5.5.2, add to the requirements:"*/
458 if (flags & SBRDEC_QUAD_RATE) {
459 int k;
460 for (k = 1; k < *numMaster; k++) {
461 if (!(v_k_master[k] - v_k_master[k - 1] <= k0 - 2)) {
462 return SBRDEC_UNSUPPORTED_CONFIG;
463 }
464 }
465 }
466
467 /*
468 Print out the calculated table
469 */
470
471 return SBRDEC_OK;
472 }
473
474 /*!
475 \brief Calculate frequency ratio of one SBR band
476
477 All SBR bands should span a constant frequency range in the logarithmic
478 domain. This function calculates the ratio of any SBR band's upper and lower
479 frequency.
480
481 \return num_band-th root of k_start/k_stop
482 */
calcFactorPerBand(int k_start,int k_stop,int num_bands)483 static FIXP_SGL calcFactorPerBand(int k_start, int k_stop, int num_bands) {
484 /* Scaled bandfactor and step 1 bit right to avoid overflow
485 * use double data type */
486 FIXP_DBL bandfactor = FL2FXCONST_DBL(0.25f); /* Start value */
487 FIXP_DBL step = FL2FXCONST_DBL(0.125f); /* Initial increment for factor */
488
489 int direction = 1;
490
491 /* Because saturation can't be done in INT IIS,
492 * changed start and stop data type from FIXP_SGL to FIXP_DBL */
493 FIXP_DBL start = k_start << (DFRACT_BITS - 8);
494 FIXP_DBL stop = k_stop << (DFRACT_BITS - 8);
495
496 FIXP_DBL temp;
497
498 int j, i = 0;
499
500 while (step > FL2FXCONST_DBL(0.0f)) {
501 i++;
502 temp = stop;
503
504 /* Calculate temp^num_bands: */
505 for (j = 0; j < num_bands; j++)
506 // temp = fMult(temp,bandfactor);
507 temp = fMultDiv2(temp, bandfactor) << 2;
508
509 if (temp < start) { /* Factor too strong, make it weaker */
510 if (direction == 0)
511 /* Halfen step. Right shift is not done as fract because otherwise the
512 lowest bit cannot be cleared due to rounding */
513 step = (FIXP_DBL)((LONG)step >> 1);
514 direction = 1;
515 bandfactor = bandfactor + step;
516 } else { /* Factor is too weak: make it stronger */
517 if (direction == 1) step = (FIXP_DBL)((LONG)step >> 1);
518 direction = 0;
519 bandfactor = bandfactor - step;
520 }
521
522 if (i > 100) {
523 step = FL2FXCONST_DBL(0.0f);
524 }
525 }
526 return FX_DBL2FX_SGL(bandfactor << 1);
527 }
528
529 /*!
530 \brief Calculate number of SBR bands between start and stop band
531
532 Given the number of bands per octave, this function calculates how many
533 bands fit in the given frequency range.
534 When the warpFlag is set, the 'band density' is decreased by a factor
535 of 1/1.3
536
537 \return number of bands
538 */
numberOfBands(FIXP_SGL bpo_div16,int start,int stop,int warpFlag)539 static int numberOfBands(
540 FIXP_SGL bpo_div16, /*!< Input: number of bands per octave divided by 16 */
541 int start, /*!< First QMF band of SBR frequency range */
542 int stop, /*!< Last QMF band of SBR frequency range + 1 */
543 int warpFlag) /*!< Stretching flag */
544 {
545 FIXP_SGL num_bands_div128;
546 int num_bands;
547
548 num_bands_div128 =
549 FX_DBL2FX_SGL(fMult(FDK_getNumOctavesDiv8(start, stop), bpo_div16));
550
551 if (warpFlag) {
552 /* Apply the warp factor of 1.3 to get wider bands. We use a value
553 of 32768/25200 instead of the exact value to avoid critical cases
554 of rounding.
555 */
556 num_bands_div128 = FX_DBL2FX_SGL(
557 fMult(num_bands_div128, FL2FXCONST_SGL(25200.0 / 32768.0)));
558 }
559
560 /* add scaled 1 for rounding to even numbers: */
561 num_bands_div128 = num_bands_div128 + FL2FXCONST_SGL(1.0f / 128.0f);
562 /* scale back to right aligned integer and double the value: */
563 num_bands = 2 * ((LONG)num_bands_div128 >> (FRACT_BITS - 7));
564
565 return (num_bands);
566 }
567
568 /*!
569 \brief Calculate width of SBR bands
570
571 Given the desired number of bands within the SBR frequency range,
572 this function calculates the width of each SBR band in QMF channels.
573 The bands get wider from start to stop (bark scale).
574 */
CalcBands(UCHAR * diff,UCHAR start,UCHAR stop,UCHAR num_bands)575 static void CalcBands(UCHAR *diff, /*!< Vector of widths to be calculated */
576 UCHAR start, /*!< Lower end of subband range */
577 UCHAR stop, /*!< Upper end of subband range */
578 UCHAR num_bands) /*!< Desired number of bands */
579 {
580 int i;
581 int previous;
582 int current;
583 FIXP_SGL exact, temp;
584 FIXP_SGL bandfactor = calcFactorPerBand(start, stop, num_bands);
585
586 previous = stop; /* Start with highest QMF channel */
587 exact = (FIXP_SGL)(
588 stop << (FRACT_BITS - 8)); /* Shift left to gain some accuracy */
589
590 for (i = num_bands - 1; i >= 0; i--) {
591 /* Calculate border of next lower sbr band */
592 exact = FX_DBL2FX_SGL(fMult(exact, bandfactor));
593
594 /* Add scaled 0.5 for rounding:
595 We use a value 128/256 instead of 0.5 to avoid some critical cases of
596 rounding. */
597 temp = exact + FL2FXCONST_SGL(128.0 / 32768.0);
598
599 /* scale back to right alinged integer: */
600 current = (LONG)temp >> (FRACT_BITS - 8);
601
602 /* Save width of band i */
603 diff[i] = previous - current;
604 previous = current;
605 }
606 }
607
608 /*!
609 \brief Calculate cumulated sum vector from delta vector
610 */
cumSum(UCHAR start_value,UCHAR * diff,UCHAR length,UCHAR * start_adress)611 static void cumSum(UCHAR start_value, UCHAR *diff, UCHAR length,
612 UCHAR *start_adress) {
613 int i;
614 start_adress[0] = start_value;
615 for (i = 1; i <= length; i++)
616 start_adress[i] = start_adress[i - 1] + diff[i - 1];
617 }
618
619 /*!
620 \brief Adapt width of frequency bands in the second region
621
622 If SBR spans more than 2 octaves, the upper part of a bark-frequency-scale
623 is calculated separately. This function tries to avoid that the second region
624 starts with a band smaller than the highest band of the first region.
625 */
modifyBands(UCHAR max_band_previous,UCHAR * diff,UCHAR length)626 static SBR_ERROR modifyBands(UCHAR max_band_previous, UCHAR *diff,
627 UCHAR length) {
628 int change = max_band_previous - diff[0];
629
630 /* Limit the change so that the last band cannot get narrower than the first
631 * one */
632 if (change > (diff[length - 1] - diff[0]) >> 1)
633 change = (diff[length - 1] - diff[0]) >> 1;
634
635 diff[0] += change;
636 diff[length - 1] -= change;
637 shellsort(diff, length);
638
639 return SBRDEC_OK;
640 }
641
642 /*!
643 \brief Update high resolution frequency band table
644 */
sbrdecUpdateHiRes(UCHAR * h_hires,UCHAR * num_hires,UCHAR * v_k_master,UCHAR num_bands,UCHAR xover_band)645 static void sbrdecUpdateHiRes(UCHAR *h_hires, UCHAR *num_hires,
646 UCHAR *v_k_master, UCHAR num_bands,
647 UCHAR xover_band) {
648 UCHAR i;
649
650 *num_hires = num_bands - xover_band;
651
652 for (i = xover_band; i <= num_bands; i++) {
653 h_hires[i - xover_band] = v_k_master[i];
654 }
655 }
656
657 /*!
658 \brief Build low resolution table out of high resolution table
659 */
sbrdecUpdateLoRes(UCHAR * h_lores,UCHAR * num_lores,UCHAR * h_hires,UCHAR num_hires)660 static void sbrdecUpdateLoRes(UCHAR *h_lores, UCHAR *num_lores, UCHAR *h_hires,
661 UCHAR num_hires) {
662 UCHAR i;
663
664 if ((num_hires & 1) == 0) {
665 /* If even number of hires bands */
666 *num_lores = num_hires >> 1;
667 /* Use every second lores=hires[0,2,4...] */
668 for (i = 0; i <= *num_lores; i++) h_lores[i] = h_hires[i * 2];
669 } else {
670 /* Odd number of hires, which means xover is odd */
671 *num_lores = (num_hires + 1) >> 1;
672 /* Use lores=hires[0,1,3,5 ...] */
673 h_lores[0] = h_hires[0];
674 for (i = 1; i <= *num_lores; i++) {
675 h_lores[i] = h_hires[i * 2 - 1];
676 }
677 }
678 }
679
680 /*!
681 \brief Derive a low-resolution frequency-table from the master frequency
682 table
683 */
sbrdecDownSampleLoRes(UCHAR * v_result,UCHAR num_result,UCHAR * freqBandTableRef,UCHAR num_Ref)684 void sbrdecDownSampleLoRes(UCHAR *v_result, UCHAR num_result,
685 UCHAR *freqBandTableRef, UCHAR num_Ref) {
686 int step;
687 int i, j;
688 int org_length, result_length;
689 int v_index[MAX_FREQ_COEFFS >> 1];
690
691 /* init */
692 org_length = num_Ref;
693 result_length = num_result;
694
695 v_index[0] = 0; /* Always use left border */
696 i = 0;
697 while (org_length > 0) {
698 /* Create downsample vector */
699 i++;
700 step = org_length / result_length;
701 org_length = org_length - step;
702 result_length--;
703 v_index[i] = v_index[i - 1] + step;
704 }
705
706 for (j = 0; j <= i; j++) {
707 /* Use downsample vector to index LoResolution vector */
708 v_result[j] = freqBandTableRef[v_index[j]];
709 }
710 }
711
712 /*!
713 \brief Sorting routine
714 */
shellsort(UCHAR * in,UCHAR n)715 void shellsort(UCHAR *in, UCHAR n) {
716 int i, j, v, w;
717 int inc = 1;
718
719 do
720 inc = 3 * inc + 1;
721 while (inc <= n);
722
723 do {
724 inc = inc / 3;
725 for (i = inc; i < n; i++) {
726 v = in[i];
727 j = i;
728 while ((w = in[j - inc]) > v) {
729 in[j] = w;
730 j -= inc;
731 if (j < inc) break;
732 }
733 in[j] = v;
734 }
735 } while (inc > 1);
736 }
737
738 /*!
739 \brief Reset frequency band tables
740 \return errorCode, 0 if successful
741 */
742 SBR_ERROR
resetFreqBandTables(HANDLE_SBR_HEADER_DATA hHeaderData,const UINT flags)743 resetFreqBandTables(HANDLE_SBR_HEADER_DATA hHeaderData, const UINT flags) {
744 SBR_ERROR err = SBRDEC_OK;
745 int k2, kx, lsb, usb;
746 int intTemp;
747 UCHAR nBandsLo, nBandsHi;
748 HANDLE_FREQ_BAND_DATA hFreq = &hHeaderData->freqBandData;
749
750 /* Calculate master frequency function */
751 err = sbrdecUpdateFreqScale(hFreq->v_k_master, &hFreq->numMaster,
752 hHeaderData->sbrProcSmplRate, hHeaderData, flags);
753
754 if (err || (hHeaderData->bs_info.xover_band > hFreq->numMaster)) {
755 return SBRDEC_UNSUPPORTED_CONFIG;
756 }
757
758 /* Derive Hiresolution from master frequency function */
759 sbrdecUpdateHiRes(hFreq->freqBandTable[1], &nBandsHi, hFreq->v_k_master,
760 hFreq->numMaster, hHeaderData->bs_info.xover_band);
761 /* Derive Loresolution from Hiresolution */
762 sbrdecUpdateLoRes(hFreq->freqBandTable[0], &nBandsLo, hFreq->freqBandTable[1],
763 nBandsHi);
764
765 hFreq->nSfb[0] = nBandsLo;
766 hFreq->nSfb[1] = nBandsHi;
767
768 /* Check index to freqBandTable[0] */
769 if (!(nBandsLo > 0) ||
770 (nBandsLo > (((hHeaderData->numberOfAnalysisBands == 16)
771 ? MAX_FREQ_COEFFS_QUAD_RATE
772 : MAX_FREQ_COEFFS_DUAL_RATE) >>
773 1))) {
774 return SBRDEC_UNSUPPORTED_CONFIG;
775 }
776
777 lsb = hFreq->freqBandTable[0][0];
778 usb = hFreq->freqBandTable[0][nBandsLo];
779
780 /* Check for start frequency border k_x:
781 - ISO/IEC 14496-3 4.6.18.3.6 Requirements
782 - ISO/IEC 23003-3 7.5.5.2 Modifications and additions to the MPEG-4 SBR
783 tool
784 */
785 /* Note that lsb > as hHeaderData->numberOfAnalysisBands is a valid SBR config
786 * for 24 band QMF analysis. */
787 if ((lsb > ((flags & SBRDEC_QUAD_RATE) ? 16 : (32))) || (lsb >= usb)) {
788 return SBRDEC_UNSUPPORTED_CONFIG;
789 }
790
791 /* Calculate number of noise bands */
792
793 k2 = hFreq->freqBandTable[1][nBandsHi];
794 kx = hFreq->freqBandTable[1][0];
795
796 if (hHeaderData->bs_data.noise_bands == 0) {
797 hFreq->nNfb = 1;
798 } else /* Calculate no of noise bands 1,2 or 3 bands/octave */
799 {
800 /* Fetch number of octaves divided by 32 */
801 intTemp = (LONG)FDK_getNumOctavesDiv8(kx, k2) >> 2;
802
803 /* Integer-Multiplication with number of bands: */
804 intTemp = intTemp * hHeaderData->bs_data.noise_bands;
805
806 /* Add scaled 0.5 for rounding: */
807 intTemp = intTemp + (LONG)FL2FXCONST_SGL(0.5f / 32.0f);
808
809 /* Convert to right-aligned integer: */
810 intTemp = intTemp >> (FRACT_BITS - 1 /*sign*/ - 5 /* rescale */);
811
812 if (intTemp == 0) intTemp = 1;
813
814 hFreq->nNfb = intTemp;
815 }
816
817 hFreq->nInvfBands = hFreq->nNfb;
818
819 if (hFreq->nNfb > MAX_NOISE_COEFFS) {
820 return SBRDEC_UNSUPPORTED_CONFIG;
821 }
822
823 /* Get noise bands */
824 sbrdecDownSampleLoRes(hFreq->freqBandTableNoise, hFreq->nNfb,
825 hFreq->freqBandTable[0], nBandsLo);
826
827 /* save old highband; required for overlap in usac
828 when headerchange occurs at XVAR and VARX frame; */
829 hFreq->ov_highSubband = hFreq->highSubband;
830
831 hFreq->lowSubband = lsb;
832 hFreq->highSubband = usb;
833
834 return SBRDEC_OK;
835 }
836