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