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 envelope decoding
106 This module provides envelope decoding and error concealment algorithms. The
107 main entry point is decodeSbrData().
108
109 \sa decodeSbrData(),\ref documentationOverview
110 */
111
112 #include "env_dec.h"
113
114 #include "env_extr.h"
115 #include "transcendent.h"
116
117 #include "genericStds.h"
118
119 static void decodeEnvelope(HANDLE_SBR_HEADER_DATA hHeaderData,
120 HANDLE_SBR_FRAME_DATA h_sbr_data,
121 HANDLE_SBR_PREV_FRAME_DATA h_prev_data,
122 HANDLE_SBR_PREV_FRAME_DATA h_prev_data_otherChannel);
123 static void sbr_envelope_unmapping(HANDLE_SBR_HEADER_DATA hHeaderData,
124 HANDLE_SBR_FRAME_DATA h_data_left,
125 HANDLE_SBR_FRAME_DATA h_data_right);
126 static void requantizeEnvelopeData(HANDLE_SBR_FRAME_DATA h_sbr_data,
127 int ampResolution);
128 static void deltaToLinearPcmEnvelopeDecoding(
129 HANDLE_SBR_HEADER_DATA hHeaderData, HANDLE_SBR_FRAME_DATA h_sbr_data,
130 HANDLE_SBR_PREV_FRAME_DATA h_prev_data);
131 static void decodeNoiseFloorlevels(HANDLE_SBR_HEADER_DATA hHeaderData,
132 HANDLE_SBR_FRAME_DATA h_sbr_data,
133 HANDLE_SBR_PREV_FRAME_DATA h_prev_data);
134 static void timeCompensateFirstEnvelope(HANDLE_SBR_HEADER_DATA hHeaderData,
135 HANDLE_SBR_FRAME_DATA h_sbr_data,
136 HANDLE_SBR_PREV_FRAME_DATA h_prev_data);
137 static int checkEnvelopeData(HANDLE_SBR_HEADER_DATA hHeaderData,
138 HANDLE_SBR_FRAME_DATA h_sbr_data,
139 HANDLE_SBR_PREV_FRAME_DATA h_prev_data);
140
141 #define SBR_ENERGY_PAN_OFFSET (12 << ENV_EXP_FRACT)
142 #define SBR_MAX_ENERGY (35 << ENV_EXP_FRACT)
143
144 #define DECAY (1 << ENV_EXP_FRACT)
145
146 #if ENV_EXP_FRACT
147 #define DECAY_COUPLING \
148 (1 << (ENV_EXP_FRACT - 1)) /*!< corresponds to a value of 0.5 */
149 #else
150 #define DECAY_COUPLING \
151 1 /*!< If the energy data is not shifted, use 1 instead of 0.5 */
152 #endif
153
154 /*!
155 \brief Convert table index
156 */
indexLow2High(int offset,int index,int res)157 static int indexLow2High(int offset, /*!< mapping factor */
158 int index, /*!< index to scalefactor band */
159 int res) /*!< frequency resolution */
160 {
161 if (res == 0) {
162 if (offset >= 0) {
163 if (index < offset)
164 return (index);
165 else
166 return (2 * index - offset);
167 } else {
168 offset = -offset;
169 if (index < offset)
170 return (2 * index + index);
171 else
172 return (2 * index + offset);
173 }
174 } else
175 return (index);
176 }
177
178 /*!
179 \brief Update previous envelope value for delta-coding
180
181 The current envelope values needs to be stored for delta-coding
182 in the next frame. The stored envelope is always represented with
183 the high frequency resolution. If the current envelope uses the
184 low frequency resolution, the energy value will be mapped to the
185 corresponding high-res bands.
186 */
mapLowResEnergyVal(FIXP_SGL currVal,FIXP_SGL * prevData,int offset,int index,int res)187 static void mapLowResEnergyVal(
188 FIXP_SGL currVal, /*!< current energy value */
189 FIXP_SGL *prevData, /*!< pointer to previous data vector */
190 int offset, /*!< mapping factor */
191 int index, /*!< index to scalefactor band */
192 int res) /*!< frequeny resolution */
193 {
194 if (res == 0) {
195 if (offset >= 0) {
196 if (index < offset)
197 prevData[index] = currVal;
198 else {
199 prevData[2 * index - offset] = currVal;
200 prevData[2 * index + 1 - offset] = currVal;
201 }
202 } else {
203 offset = -offset;
204 if (index < offset) {
205 prevData[3 * index] = currVal;
206 prevData[3 * index + 1] = currVal;
207 prevData[3 * index + 2] = currVal;
208 } else {
209 prevData[2 * index + offset] = currVal;
210 prevData[2 * index + 1 + offset] = currVal;
211 }
212 }
213 } else
214 prevData[index] = currVal;
215 }
216
217 /*!
218 \brief Convert raw envelope and noisefloor data to energy levels
219
220 This function is being called by sbrDecoder_ParseElement() and provides two
221 important algorithms:
222
223 First the function decodes envelopes and noise floor levels as described in
224 requantizeEnvelopeData() and sbr_envelope_unmapping(). The function also
225 implements concealment algorithms in case there are errors within the sbr
226 data. For both operations fractional arithmetic is used. Therefore you might
227 encounter different output values on your target system compared to the
228 reference implementation.
229 */
decodeSbrData(HANDLE_SBR_HEADER_DATA hHeaderData,HANDLE_SBR_FRAME_DATA h_data_left,HANDLE_SBR_PREV_FRAME_DATA h_prev_data_left,HANDLE_SBR_FRAME_DATA h_data_right,HANDLE_SBR_PREV_FRAME_DATA h_prev_data_right)230 void decodeSbrData(
231 HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
232 HANDLE_SBR_FRAME_DATA
233 h_data_left, /*!< pointer to left channel frame data */
234 HANDLE_SBR_PREV_FRAME_DATA
235 h_prev_data_left, /*!< pointer to left channel previous frame data */
236 HANDLE_SBR_FRAME_DATA
237 h_data_right, /*!< pointer to right channel frame data */
238 HANDLE_SBR_PREV_FRAME_DATA
239 h_prev_data_right) /*!< pointer to right channel previous frame data */
240 {
241 FIXP_SGL tempSfbNrgPrev[MAX_FREQ_COEFFS];
242 int errLeft;
243
244 /* Save previous energy values to be able to reuse them later for concealment.
245 */
246 FDKmemcpy(tempSfbNrgPrev, h_prev_data_left->sfb_nrg_prev,
247 MAX_FREQ_COEFFS * sizeof(FIXP_SGL));
248
249 if (hHeaderData->frameErrorFlag || hHeaderData->bs_info.pvc_mode == 0) {
250 decodeEnvelope(hHeaderData, h_data_left, h_prev_data_left,
251 h_prev_data_right);
252 } else {
253 FDK_ASSERT(h_data_right == NULL);
254 }
255 decodeNoiseFloorlevels(hHeaderData, h_data_left, h_prev_data_left);
256
257 if (h_data_right != NULL) {
258 errLeft = hHeaderData->frameErrorFlag;
259 decodeEnvelope(hHeaderData, h_data_right, h_prev_data_right,
260 h_prev_data_left);
261 decodeNoiseFloorlevels(hHeaderData, h_data_right, h_prev_data_right);
262
263 if (!errLeft && hHeaderData->frameErrorFlag) {
264 /* If an error occurs in the right channel where the left channel seemed
265 ok, we apply concealment also on the left channel. This ensures that
266 the coupling modes of both channels match and that we have the same
267 number of envelopes in coupling mode. However, as the left channel has
268 already been processed before, the resulting energy levels are not the
269 same as if the left channel had been concealed during the first call of
270 decodeEnvelope().
271 */
272 /* Restore previous energy values for concealment, because the values have
273 been overwritten by the first call of decodeEnvelope(). */
274 FDKmemcpy(h_prev_data_left->sfb_nrg_prev, tempSfbNrgPrev,
275 MAX_FREQ_COEFFS * sizeof(FIXP_SGL));
276 /* Do concealment */
277 decodeEnvelope(hHeaderData, h_data_left, h_prev_data_left,
278 h_prev_data_right);
279 }
280
281 if (h_data_left->coupling) {
282 sbr_envelope_unmapping(hHeaderData, h_data_left, h_data_right);
283 }
284 }
285
286 /* Display the data for debugging: */
287 }
288
289 /*!
290 \brief Convert from coupled channels to independent L/R data
291 */
sbr_envelope_unmapping(HANDLE_SBR_HEADER_DATA hHeaderData,HANDLE_SBR_FRAME_DATA h_data_left,HANDLE_SBR_FRAME_DATA h_data_right)292 static void sbr_envelope_unmapping(
293 HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
294 HANDLE_SBR_FRAME_DATA h_data_left, /*!< pointer to left channel */
295 HANDLE_SBR_FRAME_DATA h_data_right) /*!< pointer to right channel */
296 {
297 int i;
298 FIXP_SGL tempL_m, tempR_m, tempRplus1_m, newL_m, newR_m;
299 SCHAR tempL_e, tempR_e, tempRplus1_e, newL_e, newR_e;
300
301 /* 1. Unmap (already dequantized) coupled envelope energies */
302
303 for (i = 0; i < h_data_left->nScaleFactors; i++) {
304 tempR_m = (FIXP_SGL)((LONG)h_data_right->iEnvelope[i] & MASK_M);
305 tempR_e = (SCHAR)((LONG)h_data_right->iEnvelope[i] & MASK_E);
306
307 tempR_e -= (18 + NRG_EXP_OFFSET); /* -18 = ld(UNMAPPING_SCALE /
308 h_data_right->nChannels) */
309 tempL_m = (FIXP_SGL)((LONG)h_data_left->iEnvelope[i] & MASK_M);
310 tempL_e = (SCHAR)((LONG)h_data_left->iEnvelope[i] & MASK_E);
311
312 tempL_e -= NRG_EXP_OFFSET;
313
314 /* Calculate tempRight+1 */
315 FDK_add_MantExp(tempR_m, tempR_e, FL2FXCONST_SGL(0.5f), 1, /* 1.0 */
316 &tempRplus1_m, &tempRplus1_e);
317
318 FDK_divide_MantExp(tempL_m, tempL_e + 1, /* 2 * tempLeft */
319 tempRplus1_m, tempRplus1_e, &newR_m, &newR_e);
320
321 if (newR_m >= ((FIXP_SGL)MAXVAL_SGL - ROUNDING)) {
322 newR_m >>= 1;
323 newR_e += 1;
324 }
325
326 newL_m = FX_DBL2FX_SGL(fMult(tempR_m, newR_m));
327 newL_e = tempR_e + newR_e;
328
329 h_data_right->iEnvelope[i] =
330 ((FIXP_SGL)((SHORT)(FIXP_SGL)(newR_m + ROUNDING) & MASK_M)) +
331 (FIXP_SGL)((SHORT)(FIXP_SGL)(newR_e + NRG_EXP_OFFSET) & MASK_E);
332 h_data_left->iEnvelope[i] =
333 ((FIXP_SGL)((SHORT)(FIXP_SGL)(newL_m + ROUNDING) & MASK_M)) +
334 (FIXP_SGL)((SHORT)(FIXP_SGL)(newL_e + NRG_EXP_OFFSET) & MASK_E);
335 }
336
337 /* 2. Dequantize and unmap coupled noise floor levels */
338
339 for (i = 0; i < hHeaderData->freqBandData.nNfb *
340 h_data_left->frameInfo.nNoiseEnvelopes;
341 i++) {
342 tempL_e = (SCHAR)(6 - (LONG)h_data_left->sbrNoiseFloorLevel[i]);
343 tempR_e = (SCHAR)((LONG)h_data_right->sbrNoiseFloorLevel[i] -
344 12) /*SBR_ENERGY_PAN_OFFSET*/;
345
346 /* Calculate tempR+1 */
347 FDK_add_MantExp(FL2FXCONST_SGL(0.5f), 1 + tempR_e, /* tempR */
348 FL2FXCONST_SGL(0.5f), 1, /* 1.0 */
349 &tempRplus1_m, &tempRplus1_e);
350
351 /* Calculate 2*tempLeft/(tempR+1) */
352 FDK_divide_MantExp(FL2FXCONST_SGL(0.5f), tempL_e + 2, /* 2 * tempLeft */
353 tempRplus1_m, tempRplus1_e, &newR_m, &newR_e);
354
355 /* if (newR_m >= ((FIXP_SGL)MAXVAL_SGL - ROUNDING)) {
356 newR_m >>= 1;
357 newR_e += 1;
358 } */
359
360 /* L = tempR * R */
361 newL_m = newR_m;
362 newL_e = newR_e + tempR_e;
363 h_data_right->sbrNoiseFloorLevel[i] =
364 ((FIXP_SGL)((SHORT)(FIXP_SGL)(newR_m + ROUNDING) & MASK_M)) +
365 (FIXP_SGL)((SHORT)(FIXP_SGL)(newR_e + NOISE_EXP_OFFSET) & MASK_E);
366 h_data_left->sbrNoiseFloorLevel[i] =
367 ((FIXP_SGL)((SHORT)(FIXP_SGL)(newL_m + ROUNDING) & MASK_M)) +
368 (FIXP_SGL)((SHORT)(FIXP_SGL)(newL_e + NOISE_EXP_OFFSET) & MASK_E);
369 }
370 }
371
372 /*!
373 \brief Simple alternative to the real SBR concealment
374
375 If the real frameInfo is not available due to a frame loss, a replacement will
376 be constructed with 1 envelope spanning the whole frame (FIX-FIX).
377 The delta-coded energies are set to negative values, resulting in a fade-down.
378 In case of coupling, the balance-channel will move towards the center.
379 */
leanSbrConcealment(HANDLE_SBR_HEADER_DATA hHeaderData,HANDLE_SBR_FRAME_DATA h_sbr_data,HANDLE_SBR_PREV_FRAME_DATA h_prev_data)380 static void leanSbrConcealment(
381 HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
382 HANDLE_SBR_FRAME_DATA h_sbr_data, /*!< pointer to current data */
383 HANDLE_SBR_PREV_FRAME_DATA h_prev_data /*!< pointer to data of last frame */
384 ) {
385 FIXP_SGL target; /* targeted level for sfb_nrg_prev during fade-down */
386 FIXP_SGL step; /* speed of fade */
387 int i;
388
389 int currentStartPos =
390 fMax(0, h_prev_data->stopPos - hHeaderData->numberTimeSlots);
391 int currentStopPos = hHeaderData->numberTimeSlots;
392
393 /* Use some settings of the previous frame */
394 h_sbr_data->ampResolutionCurrentFrame = h_prev_data->ampRes;
395 h_sbr_data->coupling = h_prev_data->coupling;
396 for (i = 0; i < MAX_INVF_BANDS; i++)
397 h_sbr_data->sbr_invf_mode[i] = h_prev_data->sbr_invf_mode[i];
398
399 /* Generate concealing control data */
400
401 h_sbr_data->frameInfo.nEnvelopes = 1;
402 h_sbr_data->frameInfo.borders[0] = currentStartPos;
403 h_sbr_data->frameInfo.borders[1] = currentStopPos;
404 h_sbr_data->frameInfo.freqRes[0] = 1;
405 h_sbr_data->frameInfo.tranEnv = -1; /* no transient */
406 h_sbr_data->frameInfo.nNoiseEnvelopes = 1;
407 h_sbr_data->frameInfo.bordersNoise[0] = currentStartPos;
408 h_sbr_data->frameInfo.bordersNoise[1] = currentStopPos;
409
410 h_sbr_data->nScaleFactors = hHeaderData->freqBandData.nSfb[1];
411
412 /* Generate fake envelope data */
413
414 h_sbr_data->domain_vec[0] = 1;
415
416 if (h_sbr_data->coupling == COUPLING_BAL) {
417 target = (FIXP_SGL)SBR_ENERGY_PAN_OFFSET;
418 step = (FIXP_SGL)DECAY_COUPLING;
419 } else {
420 target = FL2FXCONST_SGL(0.0f);
421 step = (FIXP_SGL)DECAY;
422 }
423 if (hHeaderData->bs_info.ampResolution == 0) {
424 target <<= 1;
425 step <<= 1;
426 }
427
428 for (i = 0; i < h_sbr_data->nScaleFactors; i++) {
429 if (h_prev_data->sfb_nrg_prev[i] > target)
430 h_sbr_data->iEnvelope[i] = -step;
431 else
432 h_sbr_data->iEnvelope[i] = step;
433 }
434
435 /* Noisefloor levels are always cleared ... */
436
437 h_sbr_data->domain_vec_noise[0] = 1;
438 FDKmemclear(h_sbr_data->sbrNoiseFloorLevel,
439 sizeof(h_sbr_data->sbrNoiseFloorLevel));
440
441 /* ... and so are the sines */
442 FDKmemclear(h_sbr_data->addHarmonics,
443 sizeof(ULONG) * ADD_HARMONICS_FLAGS_SIZE);
444 }
445
446 /*!
447 \brief Build reference energies and noise levels from bitstream elements
448 */
decodeEnvelope(HANDLE_SBR_HEADER_DATA hHeaderData,HANDLE_SBR_FRAME_DATA h_sbr_data,HANDLE_SBR_PREV_FRAME_DATA h_prev_data,HANDLE_SBR_PREV_FRAME_DATA otherChannel)449 static void decodeEnvelope(
450 HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
451 HANDLE_SBR_FRAME_DATA h_sbr_data, /*!< pointer to current data */
452 HANDLE_SBR_PREV_FRAME_DATA
453 h_prev_data, /*!< pointer to data of last frame */
454 HANDLE_SBR_PREV_FRAME_DATA
455 otherChannel /*!< other channel's last frame data */
456 ) {
457 int i;
458 int fFrameError = hHeaderData->frameErrorFlag;
459 FIXP_SGL tempSfbNrgPrev[MAX_FREQ_COEFFS];
460
461 if (!fFrameError) {
462 /*
463 To avoid distortions after bad frames, set the error flag if delta coding
464 in time occurs. However, SBR can take a little longer to come up again.
465 */
466 if (h_prev_data->frameErrorFlag) {
467 if (h_sbr_data->domain_vec[0] != 0) {
468 fFrameError = 1;
469 }
470 } else {
471 /* Check that the previous stop position and the current start position
472 match. (Could be done in checkFrameInfo(), but the previous frame data
473 is not available there) */
474 if (h_sbr_data->frameInfo.borders[0] !=
475 h_prev_data->stopPos - hHeaderData->numberTimeSlots) {
476 /* Both the previous as well as the current frame are flagged to be ok,
477 * but they do not match! */
478 if (h_sbr_data->domain_vec[0] == 1) {
479 /* Prefer concealment over delta-time coding between the mismatching
480 * frames */
481 fFrameError = 1;
482 } else {
483 /* Close the gap in time by triggering timeCompensateFirstEnvelope()
484 */
485 fFrameError = 1;
486 }
487 }
488 }
489 }
490
491 if (fFrameError) /* Error is detected */
492 {
493 leanSbrConcealment(hHeaderData, h_sbr_data, h_prev_data);
494
495 /* decode the envelope data to linear PCM */
496 deltaToLinearPcmEnvelopeDecoding(hHeaderData, h_sbr_data, h_prev_data);
497 } else /*Do a temporary dummy decoding and check that the envelope values are
498 within limits */
499 {
500 if (h_prev_data->frameErrorFlag) {
501 timeCompensateFirstEnvelope(hHeaderData, h_sbr_data, h_prev_data);
502 if (h_sbr_data->coupling != h_prev_data->coupling) {
503 /*
504 Coupling mode has changed during concealment.
505 The stored energy levels need to be converted.
506 */
507 for (i = 0; i < hHeaderData->freqBandData.nSfb[1]; i++) {
508 /* Former Level-Channel will be used for both channels */
509 if (h_prev_data->coupling == COUPLING_BAL) {
510 h_prev_data->sfb_nrg_prev[i] =
511 (otherChannel != NULL) ? otherChannel->sfb_nrg_prev[i]
512 : (FIXP_SGL)SBR_ENERGY_PAN_OFFSET;
513 }
514 /* Former L/R will be combined as the new Level-Channel */
515 else if (h_sbr_data->coupling == COUPLING_LEVEL &&
516 otherChannel != NULL) {
517 h_prev_data->sfb_nrg_prev[i] = (h_prev_data->sfb_nrg_prev[i] +
518 otherChannel->sfb_nrg_prev[i]) >>
519 1;
520 } else if (h_sbr_data->coupling == COUPLING_BAL) {
521 h_prev_data->sfb_nrg_prev[i] = (FIXP_SGL)SBR_ENERGY_PAN_OFFSET;
522 }
523 }
524 }
525 }
526 FDKmemcpy(tempSfbNrgPrev, h_prev_data->sfb_nrg_prev,
527 MAX_FREQ_COEFFS * sizeof(FIXP_SGL));
528
529 deltaToLinearPcmEnvelopeDecoding(hHeaderData, h_sbr_data, h_prev_data);
530
531 fFrameError = checkEnvelopeData(hHeaderData, h_sbr_data, h_prev_data);
532
533 if (fFrameError) {
534 hHeaderData->frameErrorFlag = 1;
535 FDKmemcpy(h_prev_data->sfb_nrg_prev, tempSfbNrgPrev,
536 MAX_FREQ_COEFFS * sizeof(FIXP_SGL));
537 decodeEnvelope(hHeaderData, h_sbr_data, h_prev_data, otherChannel);
538 return;
539 }
540 }
541
542 requantizeEnvelopeData(h_sbr_data, h_sbr_data->ampResolutionCurrentFrame);
543
544 hHeaderData->frameErrorFlag = fFrameError;
545 }
546
547 /*!
548 \brief Verify that envelope energies are within the allowed range
549 \return 0 if all is fine, 1 if an envelope value was too high
550 */
checkEnvelopeData(HANDLE_SBR_HEADER_DATA hHeaderData,HANDLE_SBR_FRAME_DATA h_sbr_data,HANDLE_SBR_PREV_FRAME_DATA h_prev_data)551 static int checkEnvelopeData(
552 HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
553 HANDLE_SBR_FRAME_DATA h_sbr_data, /*!< pointer to current data */
554 HANDLE_SBR_PREV_FRAME_DATA h_prev_data /*!< pointer to data of last frame */
555 ) {
556 FIXP_SGL *iEnvelope = h_sbr_data->iEnvelope;
557 FIXP_SGL *sfb_nrg_prev = h_prev_data->sfb_nrg_prev;
558 int i = 0, errorFlag = 0;
559 FIXP_SGL sbr_max_energy = (h_sbr_data->ampResolutionCurrentFrame == 1)
560 ? SBR_MAX_ENERGY
561 : (SBR_MAX_ENERGY << 1);
562
563 /*
564 Range check for current energies
565 */
566 for (i = 0; i < h_sbr_data->nScaleFactors; i++) {
567 if (iEnvelope[i] > sbr_max_energy) {
568 errorFlag = 1;
569 }
570 if (iEnvelope[i] < FL2FXCONST_SGL(0.0f)) {
571 errorFlag = 1;
572 /* iEnvelope[i] = FL2FXCONST_SGL(0.0f); */
573 }
574 }
575
576 /*
577 Range check for previous energies
578 */
579 for (i = 0; i < hHeaderData->freqBandData.nSfb[1]; i++) {
580 sfb_nrg_prev[i] = fixMax(sfb_nrg_prev[i], FL2FXCONST_SGL(0.0f));
581 sfb_nrg_prev[i] = fixMin(sfb_nrg_prev[i], sbr_max_energy);
582 }
583
584 return (errorFlag);
585 }
586
587 /*!
588 \brief Verify that the noise levels are within the allowed range
589
590 The function is equivalent to checkEnvelopeData().
591 When the noise-levels are being decoded, it is already too late for
592 concealment. Therefore the noise levels are simply limited here.
593 */
limitNoiseLevels(HANDLE_SBR_HEADER_DATA hHeaderData,HANDLE_SBR_FRAME_DATA h_sbr_data)594 static void limitNoiseLevels(
595 HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
596 HANDLE_SBR_FRAME_DATA h_sbr_data) /*!< pointer to current data */
597 {
598 int i;
599 int nNfb = hHeaderData->freqBandData.nNfb;
600
601 /*
602 Set range limits. The exact values depend on the coupling mode.
603 However this limitation is primarily intended to avoid unlimited
604 accumulation of the delta-coded noise levels.
605 */
606 #define lowerLimit \
607 ((FIXP_SGL)0) /* lowerLimit actually refers to the _highest_ noise energy */
608 #define upperLimit \
609 ((FIXP_SGL)35) /* upperLimit actually refers to the _lowest_ noise energy */
610
611 /*
612 Range check for current noise levels
613 */
614 for (i = 0; i < h_sbr_data->frameInfo.nNoiseEnvelopes * nNfb; i++) {
615 h_sbr_data->sbrNoiseFloorLevel[i] =
616 fixMin(h_sbr_data->sbrNoiseFloorLevel[i], upperLimit);
617 h_sbr_data->sbrNoiseFloorLevel[i] =
618 fixMax(h_sbr_data->sbrNoiseFloorLevel[i], lowerLimit);
619 }
620 }
621
622 /*!
623 \brief Compensate for the wrong timing that might occur after a frame error.
624 */
timeCompensateFirstEnvelope(HANDLE_SBR_HEADER_DATA hHeaderData,HANDLE_SBR_FRAME_DATA h_sbr_data,HANDLE_SBR_PREV_FRAME_DATA h_prev_data)625 static void timeCompensateFirstEnvelope(
626 HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
627 HANDLE_SBR_FRAME_DATA h_sbr_data, /*!< pointer to actual data */
628 HANDLE_SBR_PREV_FRAME_DATA
629 h_prev_data) /*!< pointer to data of last frame */
630 {
631 int i, nScalefactors;
632 FRAME_INFO *pFrameInfo = &h_sbr_data->frameInfo;
633 UCHAR *nSfb = hHeaderData->freqBandData.nSfb;
634 int estimatedStartPos =
635 fMax(0, h_prev_data->stopPos - hHeaderData->numberTimeSlots);
636 int refLen, newLen, shift;
637 FIXP_SGL deltaExp;
638
639 /* Original length of first envelope according to bitstream */
640 refLen = pFrameInfo->borders[1] - pFrameInfo->borders[0];
641 /* Corrected length of first envelope (concealing can make the first envelope
642 * longer) */
643 newLen = pFrameInfo->borders[1] - estimatedStartPos;
644
645 if (newLen <= 0) {
646 /* An envelope length of <= 0 would not work, so we don't use it.
647 May occur if the previous frame was flagged bad due to a mismatch
648 of the old and new frame infos. */
649 newLen = refLen;
650 estimatedStartPos = pFrameInfo->borders[0];
651 }
652
653 deltaExp = FDK_getNumOctavesDiv8(newLen, refLen);
654
655 /* Shift by -3 to rescale ld-table, ampRes-1 to enable coarser steps */
656 shift = (FRACT_BITS - 1 - ENV_EXP_FRACT - 1 +
657 h_sbr_data->ampResolutionCurrentFrame - 3);
658 deltaExp = deltaExp >> shift;
659 pFrameInfo->borders[0] = estimatedStartPos;
660 pFrameInfo->bordersNoise[0] = estimatedStartPos;
661
662 if (h_sbr_data->coupling != COUPLING_BAL) {
663 nScalefactors = (pFrameInfo->freqRes[0]) ? nSfb[1] : nSfb[0];
664
665 for (i = 0; i < nScalefactors; i++)
666 h_sbr_data->iEnvelope[i] = h_sbr_data->iEnvelope[i] + deltaExp;
667 }
668 }
669
670 /*!
671 \brief Convert each envelope value from logarithmic to linear domain
672
673 Energy levels are transmitted in powers of 2, i.e. only the exponent
674 is extracted from the bitstream.
675 Therefore, normally only integer exponents can occur. However during
676 fading (in case of a corrupt bitstream), a fractional part can also
677 occur. The data in the array iEnvelope is shifted left by ENV_EXP_FRACT
678 compared to an integer representation so that numbers smaller than 1
679 can be represented.
680
681 This function calculates a mantissa corresponding to the fractional
682 part of the exponent for each reference energy. The array iEnvelope
683 is converted in place to save memory. Input and output data must
684 be interpreted differently, as shown in the below figure:
685
686 \image html EnvelopeData.png
687
688 The data is then used in calculateSbrEnvelope().
689 */
requantizeEnvelopeData(HANDLE_SBR_FRAME_DATA h_sbr_data,int ampResolution)690 static void requantizeEnvelopeData(HANDLE_SBR_FRAME_DATA h_sbr_data,
691 int ampResolution) {
692 int i;
693 FIXP_SGL mantissa;
694 int ampShift = 1 - ampResolution;
695 int exponent;
696
697 /* In case that ENV_EXP_FRACT is changed to something else but 0 or 8,
698 the initialization of this array has to be adapted!
699 */
700 #if ENV_EXP_FRACT
701 static const FIXP_SGL pow2[ENV_EXP_FRACT] = {
702 FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 1))), /* 0.7071 */
703 FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 2))), /* 0.5946 */
704 FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 3))),
705 FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 4))),
706 FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 5))),
707 FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 6))),
708 FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 7))),
709 FL2FXCONST_SGL(0.5f * pow(2.0f, pow(0.5f, 8))) /* 0.5013 */
710 };
711
712 int bit, mask;
713 #endif
714
715 for (i = 0; i < h_sbr_data->nScaleFactors; i++) {
716 exponent = (LONG)h_sbr_data->iEnvelope[i];
717
718 #if ENV_EXP_FRACT
719
720 exponent = exponent >> ampShift;
721 mantissa = 0.5f;
722
723 /* Amplify mantissa according to the fractional part of the
724 exponent (result will be between 0.500000 and 0.999999)
725 */
726 mask = 1; /* begin with lowest bit of exponent */
727
728 for (bit = ENV_EXP_FRACT - 1; bit >= 0; bit--) {
729 if (exponent & mask) {
730 /* The current bit of the exponent is set,
731 multiply mantissa with the corresponding factor: */
732 mantissa = (FIXP_SGL)((mantissa * pow2[bit]) << 1);
733 }
734 /* Advance to next bit */
735 mask = mask << 1;
736 }
737
738 /* Make integer part of exponent right aligned */
739 exponent = exponent >> ENV_EXP_FRACT;
740
741 #else
742 /* In case of the high amplitude resolution, 1 bit of the exponent gets lost
743 by the shift. This will be compensated by a mantissa of 0.5*sqrt(2)
744 instead of 0.5 if that bit is 1. */
745 mantissa = (exponent & ampShift) ? FL2FXCONST_SGL(0.707106781186548f)
746 : FL2FXCONST_SGL(0.5f);
747 exponent = exponent >> ampShift;
748 #endif
749
750 /*
751 Mantissa was set to 0.5 (instead of 1.0, therefore increase exponent by
752 1). Multiply by L=nChannels=64 by increasing exponent by another 6.
753 => Increase exponent by 7
754 */
755 exponent += 7 + NRG_EXP_OFFSET;
756
757 /* Combine mantissa and exponent and write back the result */
758 h_sbr_data->iEnvelope[i] =
759 ((FIXP_SGL)((SHORT)(FIXP_SGL)mantissa & MASK_M)) +
760 (FIXP_SGL)((SHORT)(FIXP_SGL)exponent & MASK_E);
761 }
762 }
763
764 /*!
765 \brief Build new reference energies from old ones and delta coded data
766 */
deltaToLinearPcmEnvelopeDecoding(HANDLE_SBR_HEADER_DATA hHeaderData,HANDLE_SBR_FRAME_DATA h_sbr_data,HANDLE_SBR_PREV_FRAME_DATA h_prev_data)767 static void deltaToLinearPcmEnvelopeDecoding(
768 HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
769 HANDLE_SBR_FRAME_DATA h_sbr_data, /*!< pointer to current data */
770 HANDLE_SBR_PREV_FRAME_DATA h_prev_data) /*!< pointer to previous data */
771 {
772 int i, domain, no_of_bands, band, freqRes;
773
774 FIXP_SGL *sfb_nrg_prev = h_prev_data->sfb_nrg_prev;
775 FIXP_SGL *ptr_nrg = h_sbr_data->iEnvelope;
776
777 int offset =
778 2 * hHeaderData->freqBandData.nSfb[0] - hHeaderData->freqBandData.nSfb[1];
779
780 for (i = 0; i < h_sbr_data->frameInfo.nEnvelopes; i++) {
781 domain = h_sbr_data->domain_vec[i];
782 freqRes = h_sbr_data->frameInfo.freqRes[i];
783
784 FDK_ASSERT(freqRes >= 0 && freqRes <= 1);
785
786 no_of_bands = hHeaderData->freqBandData.nSfb[freqRes];
787
788 FDK_ASSERT(no_of_bands < (64));
789
790 if (domain == 0) {
791 mapLowResEnergyVal(*ptr_nrg, sfb_nrg_prev, offset, 0, freqRes);
792 ptr_nrg++;
793 for (band = 1; band < no_of_bands; band++) {
794 *ptr_nrg = *ptr_nrg + *(ptr_nrg - 1);
795 mapLowResEnergyVal(*ptr_nrg, sfb_nrg_prev, offset, band, freqRes);
796 ptr_nrg++;
797 }
798 } else {
799 for (band = 0; band < no_of_bands; band++) {
800 *ptr_nrg =
801 *ptr_nrg + sfb_nrg_prev[indexLow2High(offset, band, freqRes)];
802 mapLowResEnergyVal(*ptr_nrg, sfb_nrg_prev, offset, band, freqRes);
803 ptr_nrg++;
804 }
805 }
806 }
807 }
808
809 /*!
810 \brief Build new noise levels from old ones and delta coded data
811 */
decodeNoiseFloorlevels(HANDLE_SBR_HEADER_DATA hHeaderData,HANDLE_SBR_FRAME_DATA h_sbr_data,HANDLE_SBR_PREV_FRAME_DATA h_prev_data)812 static void decodeNoiseFloorlevels(
813 HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
814 HANDLE_SBR_FRAME_DATA h_sbr_data, /*!< pointer to current data */
815 HANDLE_SBR_PREV_FRAME_DATA h_prev_data) /*!< pointer to previous data */
816 {
817 int i;
818 int nNfb = hHeaderData->freqBandData.nNfb;
819 int nNoiseFloorEnvelopes = h_sbr_data->frameInfo.nNoiseEnvelopes;
820
821 /* Decode first noise envelope */
822
823 if (h_sbr_data->domain_vec_noise[0] == 0) {
824 FIXP_SGL noiseLevel = h_sbr_data->sbrNoiseFloorLevel[0];
825 for (i = 1; i < nNfb; i++) {
826 noiseLevel += h_sbr_data->sbrNoiseFloorLevel[i];
827 h_sbr_data->sbrNoiseFloorLevel[i] = noiseLevel;
828 }
829 } else {
830 for (i = 0; i < nNfb; i++) {
831 h_sbr_data->sbrNoiseFloorLevel[i] += h_prev_data->prevNoiseLevel[i];
832 }
833 }
834
835 /* If present, decode the second noise envelope
836 Note: nNoiseFloorEnvelopes can only be 1 or 2 */
837
838 if (nNoiseFloorEnvelopes > 1) {
839 if (h_sbr_data->domain_vec_noise[1] == 0) {
840 FIXP_SGL noiseLevel = h_sbr_data->sbrNoiseFloorLevel[nNfb];
841 for (i = nNfb + 1; i < 2 * nNfb; i++) {
842 noiseLevel += h_sbr_data->sbrNoiseFloorLevel[i];
843 h_sbr_data->sbrNoiseFloorLevel[i] = noiseLevel;
844 }
845 } else {
846 for (i = 0; i < nNfb; i++) {
847 h_sbr_data->sbrNoiseFloorLevel[i + nNfb] +=
848 h_sbr_data->sbrNoiseFloorLevel[i];
849 }
850 }
851 }
852
853 limitNoiseLevels(hHeaderData, h_sbr_data);
854
855 /* Update prevNoiseLevel with the last noise envelope */
856 for (i = 0; i < nNfb; i++)
857 h_prev_data->prevNoiseLevel[i] =
858 h_sbr_data->sbrNoiseFloorLevel[i + nNfb * (nNoiseFloorEnvelopes - 1)];
859
860 /* Requantize the noise floor levels in COUPLING_OFF-mode */
861 if (!h_sbr_data->coupling) {
862 int nf_e;
863
864 for (i = 0; i < nNoiseFloorEnvelopes * nNfb; i++) {
865 nf_e = 6 - (LONG)h_sbr_data->sbrNoiseFloorLevel[i] + 1 + NOISE_EXP_OFFSET;
866 /* +1 to compensate for a mantissa of 0.5 instead of 1.0 */
867
868 h_sbr_data->sbrNoiseFloorLevel[i] =
869 (FIXP_SGL)(((LONG)FL2FXCONST_SGL(0.5f)) + /* mantissa */
870 (nf_e & MASK_E)); /* exponent */
871 }
872 }
873 }
874