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 /**************************** AAC decoder library ******************************
96
97 Author(s):
98
99 Description:
100
101 *******************************************************************************/
102
103 /*!
104 \file
105 \brief rvlc concealment
106 \author Josef Hoepfl
107 */
108
109 #include "rvlcconceal.h"
110
111 #include "block.h"
112 #include "rvlc.h"
113
114 /*---------------------------------------------------------------------------------------------
115 function: calcRefValFwd
116
117 description: The function determines the scalefactor which is closed to the
118 scalefactorband conceal_min. The same is done for intensity data and noise
119 energies.
120 -----------------------------------------------------------------------------------------------
121 output: - reference value scf
122 - reference value internsity data
123 - reference value noise energy
124 -----------------------------------------------------------------------------------------------
125 return: -
126 --------------------------------------------------------------------------------------------
127 */
128
calcRefValFwd(CErRvlcInfo * pRvlc,CAacDecoderChannelInfo * pAacDecoderChannelInfo,int * refIsFwd,int * refNrgFwd,int * refScfFwd)129 static void calcRefValFwd(CErRvlcInfo *pRvlc,
130 CAacDecoderChannelInfo *pAacDecoderChannelInfo,
131 int *refIsFwd, int *refNrgFwd, int *refScfFwd) {
132 int band, bnds, group, startBand;
133 int idIs, idNrg, idScf;
134 int conceal_min, conceal_group_min;
135 int MaximumScaleFactorBands;
136
137 if (GetWindowSequence(&pAacDecoderChannelInfo->icsInfo) == BLOCK_SHORT)
138 MaximumScaleFactorBands = 16;
139 else
140 MaximumScaleFactorBands = 64;
141
142 conceal_min = pRvlc->conceal_min % MaximumScaleFactorBands;
143 conceal_group_min = pRvlc->conceal_min / MaximumScaleFactorBands;
144
145 /* calculate first reference value for approach in forward direction */
146 idIs = idNrg = idScf = 1;
147
148 /* set reference values */
149 *refIsFwd = -SF_OFFSET;
150 *refNrgFwd = pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain -
151 SF_OFFSET - 90 - 256;
152 *refScfFwd =
153 pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain - SF_OFFSET;
154
155 startBand = conceal_min - 1;
156 for (group = conceal_group_min; group >= 0; group--) {
157 for (band = startBand; band >= 0; band--) {
158 bnds = 16 * group + band;
159 switch (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds]) {
160 case ZERO_HCB:
161 break;
162 case INTENSITY_HCB:
163 case INTENSITY_HCB2:
164 if (idIs) {
165 *refIsFwd =
166 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds];
167 idIs = 0; /* reference value has been set */
168 }
169 break;
170 case NOISE_HCB:
171 if (idNrg) {
172 *refNrgFwd =
173 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds];
174 idNrg = 0; /* reference value has been set */
175 }
176 break;
177 default:
178 if (idScf) {
179 *refScfFwd =
180 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds];
181 idScf = 0; /* reference value has been set */
182 }
183 break;
184 }
185 }
186 startBand = pRvlc->maxSfbTransmitted - 1;
187 }
188 }
189
190 /*---------------------------------------------------------------------------------------------
191 function: calcRefValBwd
192
193 description: The function determines the scalefactor which is closed to the
194 scalefactorband conceal_max. The same is done for intensity data and noise
195 energies.
196 -----------------------------------------------------------------------------------------------
197 output: - reference value scf
198 - reference value internsity data
199 - reference value noise energy
200 -----------------------------------------------------------------------------------------------
201 return: -
202 --------------------------------------------------------------------------------------------
203 */
204
calcRefValBwd(CErRvlcInfo * pRvlc,CAacDecoderChannelInfo * pAacDecoderChannelInfo,int * refIsBwd,int * refNrgBwd,int * refScfBwd)205 static void calcRefValBwd(CErRvlcInfo *pRvlc,
206 CAacDecoderChannelInfo *pAacDecoderChannelInfo,
207 int *refIsBwd, int *refNrgBwd, int *refScfBwd) {
208 int band, bnds, group, startBand;
209 int idIs, idNrg, idScf;
210 int conceal_max, conceal_group_max;
211 int MaximumScaleFactorBands;
212
213 if (GetWindowSequence(&pAacDecoderChannelInfo->icsInfo) == BLOCK_SHORT)
214 MaximumScaleFactorBands = 16;
215 else
216 MaximumScaleFactorBands = 64;
217
218 conceal_max = pRvlc->conceal_max % MaximumScaleFactorBands;
219 conceal_group_max = pRvlc->conceal_max / MaximumScaleFactorBands;
220
221 /* calculate first reference value for approach in backward direction */
222 idIs = idNrg = idScf = 1;
223
224 /* set reference values */
225 *refIsBwd = pRvlc->dpcm_is_last_position - SF_OFFSET;
226 *refNrgBwd = pRvlc->rev_global_gain + pRvlc->dpcm_noise_last_position -
227 SF_OFFSET - 90 - 256 + pRvlc->dpcm_noise_nrg;
228 *refScfBwd = pRvlc->rev_global_gain - SF_OFFSET;
229
230 startBand = conceal_max + 1;
231
232 /* if needed, re-set reference values */
233 for (group = conceal_group_max; group < pRvlc->numWindowGroups; group++) {
234 for (band = startBand; band < pRvlc->maxSfbTransmitted; band++) {
235 bnds = 16 * group + band;
236 switch (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds]) {
237 case ZERO_HCB:
238 break;
239 case INTENSITY_HCB:
240 case INTENSITY_HCB2:
241 if (idIs) {
242 *refIsBwd =
243 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfBwd[bnds];
244 idIs = 0; /* reference value has been set */
245 }
246 break;
247 case NOISE_HCB:
248 if (idNrg) {
249 *refNrgBwd =
250 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfBwd[bnds];
251 idNrg = 0; /* reference value has been set */
252 }
253 break;
254 default:
255 if (idScf) {
256 *refScfBwd =
257 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfBwd[bnds];
258 idScf = 0; /* reference value has been set */
259 }
260 break;
261 }
262 }
263 startBand = 0;
264 }
265 }
266
267 /*---------------------------------------------------------------------------------------------
268 function: BidirectionalEstimation_UseLowerScfOfCurrentFrame
269
270 description: This approach by means of bidirectional estimation is generally
271 performed when a single bit error has been detected, the bit error can be
272 isolated between 'conceal_min' and 'conceal_max' and the 'sf_concealment' flag
273 is not set. The sets of scalefactors decoded in forward and backward direction
274 are compared with each other. The smaller scalefactor will be considered as the
275 correct one respectively. The reconstruction of the scalefactors with this
276 approach archieve good results in audio quality. The strategy must be applied to
277 scalefactors, intensity data and noise energy seperately.
278 -----------------------------------------------------------------------------------------------
279 output: Concealed scalefactor, noise energy and intensity data between
280 conceal_min and conceal_max
281 -----------------------------------------------------------------------------------------------
282 return: -
283 --------------------------------------------------------------------------------------------
284 */
285
BidirectionalEstimation_UseLowerScfOfCurrentFrame(CAacDecoderChannelInfo * pAacDecoderChannelInfo)286 void BidirectionalEstimation_UseLowerScfOfCurrentFrame(
287 CAacDecoderChannelInfo *pAacDecoderChannelInfo) {
288 CErRvlcInfo *pRvlc =
289 &pAacDecoderChannelInfo->pComData->overlay.aac.erRvlcInfo;
290 int band, bnds, startBand, endBand, group;
291 int conceal_min, conceal_max;
292 int conceal_group_min, conceal_group_max;
293 int MaximumScaleFactorBands;
294
295 if (GetWindowSequence(&pAacDecoderChannelInfo->icsInfo) == BLOCK_SHORT) {
296 MaximumScaleFactorBands = 16;
297 } else {
298 MaximumScaleFactorBands = 64;
299 }
300
301 /* If an error was detected just in forward or backward direction, set the
302 corresponding border for concealment to a appropriate scalefactor band. The
303 border is set to first or last sfb respectively, because the error will
304 possibly not follow directly after the corrupt bit but just after decoding
305 some more (wrong) scalefactors. */
306 if (pRvlc->conceal_min == CONCEAL_MIN_INIT) pRvlc->conceal_min = 0;
307
308 if (pRvlc->conceal_max == CONCEAL_MAX_INIT)
309 pRvlc->conceal_max =
310 (pRvlc->numWindowGroups - 1) * 16 + pRvlc->maxSfbTransmitted - 1;
311
312 conceal_min = pRvlc->conceal_min % MaximumScaleFactorBands;
313 conceal_group_min = pRvlc->conceal_min / MaximumScaleFactorBands;
314 conceal_max = pRvlc->conceal_max % MaximumScaleFactorBands;
315 conceal_group_max = pRvlc->conceal_max / MaximumScaleFactorBands;
316
317 if (pRvlc->conceal_min == pRvlc->conceal_max) {
318 int refIsFwd, refNrgFwd, refScfFwd;
319 int refIsBwd, refNrgBwd, refScfBwd;
320
321 bnds = pRvlc->conceal_min;
322 calcRefValFwd(pRvlc, pAacDecoderChannelInfo, &refIsFwd, &refNrgFwd,
323 &refScfFwd);
324 calcRefValBwd(pRvlc, pAacDecoderChannelInfo, &refIsBwd, &refNrgBwd,
325 &refScfBwd);
326
327 switch (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds]) {
328 case ZERO_HCB:
329 break;
330 case INTENSITY_HCB:
331 case INTENSITY_HCB2:
332 if (refIsFwd < refIsBwd)
333 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] = refIsFwd;
334 else
335 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] = refIsBwd;
336 break;
337 case NOISE_HCB:
338 if (refNrgFwd < refNrgBwd)
339 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] = refNrgFwd;
340 else
341 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] = refNrgBwd;
342 break;
343 default:
344 if (refScfFwd < refScfBwd)
345 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] = refScfFwd;
346 else
347 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] = refScfBwd;
348 break;
349 }
350 } else {
351 pAacDecoderChannelInfo->pComData->overlay.aac
352 .aRvlcScfFwd[pRvlc->conceal_max] =
353 pAacDecoderChannelInfo->pComData->overlay.aac
354 .aRvlcScfBwd[pRvlc->conceal_max];
355 pAacDecoderChannelInfo->pComData->overlay.aac
356 .aRvlcScfBwd[pRvlc->conceal_min] =
357 pAacDecoderChannelInfo->pComData->overlay.aac
358 .aRvlcScfFwd[pRvlc->conceal_min];
359
360 /* consider the smaller of the forward and backward decoded value as the
361 * correct one */
362 startBand = conceal_min;
363 if (conceal_group_min == conceal_group_max)
364 endBand = conceal_max;
365 else
366 endBand = pRvlc->maxSfbTransmitted - 1;
367
368 for (group = conceal_group_min; group <= conceal_group_max; group++) {
369 for (band = startBand; band <= endBand; band++) {
370 bnds = 16 * group + band;
371 if (pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds] <
372 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfBwd[bnds])
373 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] =
374 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds];
375 else
376 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] =
377 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfBwd[bnds];
378 }
379 startBand = 0;
380 if ((group + 1) == conceal_group_max) endBand = conceal_max;
381 }
382 }
383
384 /* now copy all data to the output buffer which needs not to be concealed */
385 if (conceal_group_min == 0)
386 endBand = conceal_min;
387 else
388 endBand = pRvlc->maxSfbTransmitted;
389 for (group = 0; group <= conceal_group_min; group++) {
390 for (band = 0; band < endBand; band++) {
391 bnds = 16 * group + band;
392 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] =
393 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds];
394 }
395 if ((group + 1) == conceal_group_min) endBand = conceal_min;
396 }
397
398 startBand = conceal_max + 1;
399 for (group = conceal_group_max; group < pRvlc->numWindowGroups; group++) {
400 for (band = startBand; band < pRvlc->maxSfbTransmitted; band++) {
401 bnds = 16 * group + band;
402 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] =
403 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfBwd[bnds];
404 }
405 startBand = 0;
406 }
407 }
408
409 /*---------------------------------------------------------------------------------------------
410 function: BidirectionalEstimation_UseScfOfPrevFrameAsReference
411
412 description: This approach by means of bidirectional estimation is generally
413 performed when a single bit error has been detected, the bit error can be
414 isolated between 'conceal_min' and 'conceal_max', the 'sf_concealment' flag is
415 set and the previous frame has the same block type as the current frame. The
416 scalefactor decoded in forward and backward direction and the scalefactor of the
417 previous frame are compared with each other. The smaller scalefactor will be
418 considered as the correct one. At this the codebook of the previous and current
419 frame must be of the same set (scf, nrg, is) in each scalefactorband. Otherwise
420 the scalefactor of the previous frame is not considered in the minimum
421 calculation. The reconstruction of the scalefactors with this approach archieve
422 good results in audio quality. The strategy must be applied to scalefactors,
423 intensity data and noise energy seperately.
424 -----------------------------------------------------------------------------------------------
425 output: Concealed scalefactor, noise energy and intensity data between
426 conceal_min and conceal_max
427 -----------------------------------------------------------------------------------------------
428 return: -
429 --------------------------------------------------------------------------------------------
430 */
431
BidirectionalEstimation_UseScfOfPrevFrameAsReference(CAacDecoderChannelInfo * pAacDecoderChannelInfo,CAacDecoderStaticChannelInfo * pAacDecoderStaticChannelInfo)432 void BidirectionalEstimation_UseScfOfPrevFrameAsReference(
433 CAacDecoderChannelInfo *pAacDecoderChannelInfo,
434 CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo) {
435 CErRvlcInfo *pRvlc =
436 &pAacDecoderChannelInfo->pComData->overlay.aac.erRvlcInfo;
437 int band, bnds, startBand, endBand, group;
438 int conceal_min, conceal_max;
439 int conceal_group_min, conceal_group_max;
440 int MaximumScaleFactorBands;
441 SHORT commonMin;
442
443 if (GetWindowSequence(&pAacDecoderChannelInfo->icsInfo) == BLOCK_SHORT) {
444 MaximumScaleFactorBands = 16;
445 } else {
446 MaximumScaleFactorBands = 64;
447 }
448
449 /* If an error was detected just in forward or backward direction, set the
450 corresponding border for concealment to a appropriate scalefactor band. The
451 border is set to first or last sfb respectively, because the error will
452 possibly not follow directly after the corrupt bit but just after decoding
453 some more (wrong) scalefactors. */
454 if (pRvlc->conceal_min == CONCEAL_MIN_INIT) pRvlc->conceal_min = 0;
455
456 if (pRvlc->conceal_max == CONCEAL_MAX_INIT)
457 pRvlc->conceal_max =
458 (pRvlc->numWindowGroups - 1) * 16 + pRvlc->maxSfbTransmitted - 1;
459
460 conceal_min = pRvlc->conceal_min % MaximumScaleFactorBands;
461 conceal_group_min = pRvlc->conceal_min / MaximumScaleFactorBands;
462 conceal_max = pRvlc->conceal_max % MaximumScaleFactorBands;
463 conceal_group_max = pRvlc->conceal_max / MaximumScaleFactorBands;
464
465 pAacDecoderChannelInfo->pComData->overlay.aac
466 .aRvlcScfFwd[pRvlc->conceal_max] =
467 pAacDecoderChannelInfo->pComData->overlay.aac
468 .aRvlcScfBwd[pRvlc->conceal_max];
469 pAacDecoderChannelInfo->pComData->overlay.aac
470 .aRvlcScfBwd[pRvlc->conceal_min] =
471 pAacDecoderChannelInfo->pComData->overlay.aac
472 .aRvlcScfFwd[pRvlc->conceal_min];
473
474 /* consider the smaller of the forward and backward decoded value as the
475 * correct one */
476 startBand = conceal_min;
477 if (conceal_group_min == conceal_group_max)
478 endBand = conceal_max;
479 else
480 endBand = pRvlc->maxSfbTransmitted - 1;
481
482 for (group = conceal_group_min; group <= conceal_group_max; group++) {
483 for (band = startBand; band <= endBand; band++) {
484 bnds = 16 * group + band;
485 switch (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds]) {
486 case ZERO_HCB:
487 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] = 0;
488 break;
489
490 case INTENSITY_HCB:
491 case INTENSITY_HCB2:
492 if ((pAacDecoderStaticChannelInfo->concealmentInfo
493 .aRvlcPreviousCodebook[bnds] == INTENSITY_HCB) ||
494 (pAacDecoderStaticChannelInfo->concealmentInfo
495 .aRvlcPreviousCodebook[bnds] == INTENSITY_HCB2)) {
496 commonMin = fMin(
497 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds],
498 pAacDecoderChannelInfo->pComData->overlay.aac
499 .aRvlcScfBwd[bnds]);
500 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] =
501 fMin(commonMin, pAacDecoderStaticChannelInfo->concealmentInfo
502 .aRvlcPreviousScaleFactor[bnds]);
503 } else {
504 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] = fMin(
505 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds],
506 pAacDecoderChannelInfo->pComData->overlay.aac
507 .aRvlcScfBwd[bnds]);
508 }
509 break;
510
511 case NOISE_HCB:
512 if (pAacDecoderStaticChannelInfo->concealmentInfo
513 .aRvlcPreviousCodebook[bnds] == NOISE_HCB) {
514 commonMin = fMin(
515 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds],
516 pAacDecoderChannelInfo->pComData->overlay.aac
517 .aRvlcScfBwd[bnds]);
518 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] =
519 fMin(commonMin, pAacDecoderStaticChannelInfo->concealmentInfo
520 .aRvlcPreviousScaleFactor[bnds]);
521 } else {
522 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] = fMin(
523 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds],
524 pAacDecoderChannelInfo->pComData->overlay.aac
525 .aRvlcScfBwd[bnds]);
526 }
527 break;
528
529 default:
530 if ((pAacDecoderStaticChannelInfo->concealmentInfo
531 .aRvlcPreviousCodebook[bnds] != ZERO_HCB) &&
532 (pAacDecoderStaticChannelInfo->concealmentInfo
533 .aRvlcPreviousCodebook[bnds] != NOISE_HCB) &&
534 (pAacDecoderStaticChannelInfo->concealmentInfo
535 .aRvlcPreviousCodebook[bnds] != INTENSITY_HCB) &&
536 (pAacDecoderStaticChannelInfo->concealmentInfo
537 .aRvlcPreviousCodebook[bnds] != INTENSITY_HCB2)) {
538 commonMin = fMin(
539 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds],
540 pAacDecoderChannelInfo->pComData->overlay.aac
541 .aRvlcScfBwd[bnds]);
542 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] =
543 fMin(commonMin, pAacDecoderStaticChannelInfo->concealmentInfo
544 .aRvlcPreviousScaleFactor[bnds]);
545 } else {
546 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] = fMin(
547 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds],
548 pAacDecoderChannelInfo->pComData->overlay.aac
549 .aRvlcScfBwd[bnds]);
550 }
551 break;
552 }
553 }
554 startBand = 0;
555 if ((group + 1) == conceal_group_max) endBand = conceal_max;
556 }
557
558 /* now copy all data to the output buffer which needs not to be concealed */
559 if (conceal_group_min == 0)
560 endBand = conceal_min;
561 else
562 endBand = pRvlc->maxSfbTransmitted;
563 for (group = 0; group <= conceal_group_min; group++) {
564 for (band = 0; band < endBand; band++) {
565 bnds = 16 * group + band;
566 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] =
567 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds];
568 }
569 if ((group + 1) == conceal_group_min) endBand = conceal_min;
570 }
571
572 startBand = conceal_max + 1;
573 for (group = conceal_group_max; group < pRvlc->numWindowGroups; group++) {
574 for (band = startBand; band < pRvlc->maxSfbTransmitted; band++) {
575 bnds = 16 * group + band;
576 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] =
577 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfBwd[bnds];
578 }
579 startBand = 0;
580 }
581 }
582
583 /*---------------------------------------------------------------------------------------------
584 function: StatisticalEstimation
585
586 description: This approach by means of statistical estimation is generally
587 performed when both the start value and the end value are different and no
588 further errors have been detected. Considering the forward and backward decoded
589 scalefactors, the set with the lower scalefactors in sum will be considered as
590 the correct one. The scalefactors are differentially encoded. Normally it would
591 reach to compare one pair of the forward and backward decoded scalefactors to
592 specify the lower set. But having detected no further errors does not
593 necessarily mean the absence of errors. Therefore all scalefactors decoded in
594 forward and backward direction are summed up seperately. The set with the lower
595 sum will be used. The strategy must be applied to scalefactors, intensity data
596 and noise energy seperately.
597 -----------------------------------------------------------------------------------------------
598 output: Concealed scalefactor, noise energy and intensity data
599 -----------------------------------------------------------------------------------------------
600 return: -
601 --------------------------------------------------------------------------------------------
602 */
603
StatisticalEstimation(CAacDecoderChannelInfo * pAacDecoderChannelInfo)604 void StatisticalEstimation(CAacDecoderChannelInfo *pAacDecoderChannelInfo) {
605 CErRvlcInfo *pRvlc =
606 &pAacDecoderChannelInfo->pComData->overlay.aac.erRvlcInfo;
607 int band, bnds, group;
608 int sumIsFwd, sumIsBwd; /* sum of intensity data forward/backward */
609 int sumNrgFwd, sumNrgBwd; /* sum of noise energy data forward/backward */
610 int sumScfFwd, sumScfBwd; /* sum of scalefactor data forward/backward */
611 int useIsFwd, useNrgFwd, useScfFwd; /* the flags signals the elements which
612 are used for the final result */
613
614 sumIsFwd = sumIsBwd = sumNrgFwd = sumNrgBwd = sumScfFwd = sumScfBwd = 0;
615 useIsFwd = useNrgFwd = useScfFwd = 0;
616
617 /* calculate sum of each group (scf,nrg,is) of forward and backward direction
618 */
619 for (group = 0; group < pRvlc->numWindowGroups; group++) {
620 for (band = 0; band < pRvlc->maxSfbTransmitted; band++) {
621 bnds = 16 * group + band;
622 switch (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds]) {
623 case ZERO_HCB:
624 break;
625
626 case INTENSITY_HCB:
627 case INTENSITY_HCB2:
628 sumIsFwd +=
629 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds];
630 sumIsBwd +=
631 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfBwd[bnds];
632 break;
633
634 case NOISE_HCB:
635 sumNrgFwd +=
636 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds];
637 sumNrgBwd +=
638 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfBwd[bnds];
639 break;
640
641 default:
642 sumScfFwd +=
643 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds];
644 sumScfBwd +=
645 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfBwd[bnds];
646 break;
647 }
648 }
649 }
650
651 /* find for each group (scf,nrg,is) the correct direction */
652 if (sumIsFwd < sumIsBwd) useIsFwd = 1;
653
654 if (sumNrgFwd < sumNrgBwd) useNrgFwd = 1;
655
656 if (sumScfFwd < sumScfBwd) useScfFwd = 1;
657
658 /* conceal each group (scf,nrg,is) */
659 for (group = 0; group < pRvlc->numWindowGroups; group++) {
660 for (band = 0; band < pRvlc->maxSfbTransmitted; band++) {
661 bnds = 16 * group + band;
662 switch (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds]) {
663 case ZERO_HCB:
664 break;
665
666 case INTENSITY_HCB:
667 case INTENSITY_HCB2:
668 if (useIsFwd)
669 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] =
670 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds];
671 else
672 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] =
673 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfBwd[bnds];
674 break;
675
676 case NOISE_HCB:
677 if (useNrgFwd)
678 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] =
679 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds];
680 else
681 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] =
682 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfBwd[bnds];
683 break;
684
685 default:
686 if (useScfFwd)
687 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] =
688 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds];
689 else
690 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] =
691 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfBwd[bnds];
692 break;
693 }
694 }
695 }
696 }
697
698 /*---------------------------------------------------------------------------------------------
699 description: Approach by means of predictive interpolation
700 This approach by means of predictive estimation is generally
701 performed when the error cannot be isolated between 'conceal_min' and
702 'conceal_max', the 'sf_concealment' flag is set and the previous frame has the
703 same block type as the current frame. Check for each scalefactorband if the same
704 type of data (scalefactor, internsity data, noise energies) is transmitted. If
705 so use the scalefactor (intensity data, noise energy) in the current frame.
706 Otherwise set the scalefactor (intensity data, noise energy) for this
707 scalefactorband to zero.
708 -----------------------------------------------------------------------------------------------
709 output: Concealed scalefactor, noise energy and intensity data
710 -----------------------------------------------------------------------------------------------
711 return: -
712 --------------------------------------------------------------------------------------------
713 */
714
PredictiveInterpolation(CAacDecoderChannelInfo * pAacDecoderChannelInfo,CAacDecoderStaticChannelInfo * pAacDecoderStaticChannelInfo)715 void PredictiveInterpolation(
716 CAacDecoderChannelInfo *pAacDecoderChannelInfo,
717 CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo) {
718 CErRvlcInfo *pRvlc =
719 &pAacDecoderChannelInfo->pComData->overlay.aac.erRvlcInfo;
720 int band, bnds, group;
721 SHORT commonMin;
722
723 for (group = 0; group < pRvlc->numWindowGroups; group++) {
724 for (band = 0; band < pRvlc->maxSfbTransmitted; band++) {
725 bnds = 16 * group + band;
726 switch (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds]) {
727 case ZERO_HCB:
728 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] = 0;
729 break;
730
731 case INTENSITY_HCB:
732 case INTENSITY_HCB2:
733 if ((pAacDecoderStaticChannelInfo->concealmentInfo
734 .aRvlcPreviousCodebook[bnds] == INTENSITY_HCB) ||
735 (pAacDecoderStaticChannelInfo->concealmentInfo
736 .aRvlcPreviousCodebook[bnds] == INTENSITY_HCB2)) {
737 commonMin = fMin(
738 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds],
739 pAacDecoderChannelInfo->pComData->overlay.aac
740 .aRvlcScfBwd[bnds]);
741 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] =
742 fMin(commonMin, pAacDecoderStaticChannelInfo->concealmentInfo
743 .aRvlcPreviousScaleFactor[bnds]);
744 } else {
745 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] = -110;
746 }
747 break;
748
749 case NOISE_HCB:
750 if (pAacDecoderStaticChannelInfo->concealmentInfo
751 .aRvlcPreviousCodebook[bnds] == NOISE_HCB) {
752 commonMin = fMin(
753 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds],
754 pAacDecoderChannelInfo->pComData->overlay.aac
755 .aRvlcScfBwd[bnds]);
756 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] =
757 fMin(commonMin, pAacDecoderStaticChannelInfo->concealmentInfo
758 .aRvlcPreviousScaleFactor[bnds]);
759 } else {
760 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] = -110;
761 }
762 break;
763
764 default:
765 if ((pAacDecoderStaticChannelInfo->concealmentInfo
766 .aRvlcPreviousCodebook[bnds] != ZERO_HCB) &&
767 (pAacDecoderStaticChannelInfo->concealmentInfo
768 .aRvlcPreviousCodebook[bnds] != NOISE_HCB) &&
769 (pAacDecoderStaticChannelInfo->concealmentInfo
770 .aRvlcPreviousCodebook[bnds] != INTENSITY_HCB) &&
771 (pAacDecoderStaticChannelInfo->concealmentInfo
772 .aRvlcPreviousCodebook[bnds] != INTENSITY_HCB2)) {
773 commonMin = fMin(
774 pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds],
775 pAacDecoderChannelInfo->pComData->overlay.aac
776 .aRvlcScfBwd[bnds]);
777 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] =
778 fMin(commonMin, pAacDecoderStaticChannelInfo->concealmentInfo
779 .aRvlcPreviousScaleFactor[bnds]);
780 } else {
781 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] = 0;
782 }
783 break;
784 }
785 }
786 }
787 }
788