1
2 /* -----------------------------------------------------------------------------------------------------------
3 Software License for The Fraunhofer FDK AAC Codec Library for Android
4
5 � Copyright 1995 - 2013 Fraunhofer-Gesellschaft zur F�rderung der angewandten Forschung e.V.
6 All rights reserved.
7
8 1. INTRODUCTION
9 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
10 the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
11 This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
12
13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
14 audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
15 independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
16 of the MPEG specifications.
17
18 Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
19 may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
20 individually for the purpose of encoding or decoding bit streams in products that are compliant with
21 the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
22 these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
23 software may already be covered under those patent licenses when it is used for those licensed purposes only.
24
25 Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
26 are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
27 applications information and documentation.
28
29 2. COPYRIGHT LICENSE
30
31 Redistribution and use in source and binary forms, with or without modification, are permitted without
32 payment of copyright license fees provided that you satisfy the following conditions:
33
34 You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
35 your modifications thereto in source code form.
36
37 You must retain the complete text of this software license in the documentation and/or other materials
38 provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
39 You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
40 modifications thereto to recipients of copies in binary form.
41
42 The name of Fraunhofer may not be used to endorse or promote products derived from this library without
43 prior written permission.
44
45 You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
46 software or your modifications thereto.
47
48 Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
49 and the date of any change. For modified versions of the FDK AAC Codec, the term
50 "Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
51 "Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
52
53 3. NO PATENT LICENSE
54
55 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
56 ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
57 respect to this software.
58
59 You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
60 by appropriate patent licenses.
61
62 4. DISCLAIMER
63
64 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
65 "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
66 of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
67 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
68 including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
69 or business interruption, however caused and on any theory of liability, whether in contract, strict
70 liability, or tort (including negligence), arising in any way out of the use of this software, even if
71 advised of the possibility of such damage.
72
73 5. CONTACT INFORMATION
74
75 Fraunhofer Institute for Integrated Circuits IIS
76 Attention: Audio and Multimedia Departments - FDK AAC LL
77 Am Wolfsmantel 33
78 91058 Erlangen, Germany
79
80 www.iis.fraunhofer.de/amm
81 amm-info@iis.fraunhofer.de
82 ----------------------------------------------------------------------------------------------------------- */
83
84 /*!
85 \file
86 \brief RVLC Decoder
87 \author Robert Weidner
88 */
89
90 #include "rvlc.h"
91
92
93 #include "block.h"
94
95 #include "aac_rom.h"
96 #include "rvlcbit.h"
97 #include "rvlcconceal.h"
98 #include "aacdec_hcr.h"
99
100 /*---------------------------------------------------------------------------------------------
101 function: rvlcInit
102
103 description: init RVLC by data from channelinfo, which was decoded previously and
104 set up pointers
105 -----------------------------------------------------------------------------------------------
106 input: - pointer rvlc structure
107 - pointer channel info structure
108 - pointer bitstream structure
109 -----------------------------------------------------------------------------------------------
110 return: -
111 -------------------------------------------------------------------------------------------- */
112
113 static
rvlcInit(CErRvlcInfo * pRvlc,CAacDecoderChannelInfo * pAacDecoderChannelInfo,HANDLE_FDK_BITSTREAM bs)114 void rvlcInit (CErRvlcInfo *pRvlc,
115 CAacDecoderChannelInfo *pAacDecoderChannelInfo,
116 HANDLE_FDK_BITSTREAM bs)
117 {
118 /* RVLC common initialization part 2 of 2 */
119 SHORT *pScfEsc = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfEsc;
120 SHORT *pScfFwd = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd;
121 SHORT *pScfBwd = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfBwd;
122 SHORT *pScaleFactor = pAacDecoderChannelInfo->pDynData->aScaleFactor;
123 int bnds;
124
125 pAacDecoderChannelInfo->pDynData->specificTo.aac.rvlcIntensityUsed = 0;
126
127 pRvlc->numDecodedEscapeWordsEsc = 0;
128 pRvlc->numDecodedEscapeWordsFwd = 0;
129 pRvlc->numDecodedEscapeWordsBwd = 0;
130
131 pRvlc->intensity_used = 0;
132 pRvlc->errorLogRvlc = 0;
133
134 pRvlc->conceal_max = CONCEAL_MAX_INIT;
135 pRvlc->conceal_min = CONCEAL_MIN_INIT;
136
137 pRvlc->conceal_max_esc = CONCEAL_MAX_INIT;
138 pRvlc->conceal_min_esc = CONCEAL_MIN_INIT;
139
140 pRvlc->pHuffTreeRvlcEscape = aHuffTreeRvlcEscape;
141 pRvlc->pHuffTreeRvlCodewds = aHuffTreeRvlCodewds;
142
143 /* init scf arrays (for savety (in case of there are only zero codebooks)) */
144 for (bnds = 0; bnds < RVLC_MAX_SFB; bnds++) {
145 pScfFwd[bnds] = 0;
146 pScfBwd[bnds] = 0;
147 pScfEsc[bnds] = 0;
148 pScaleFactor[bnds] = 0;
149 }
150
151 /* set base bitstream ptr to the RVL-coded part (start of RVLC data (ESC 2)) */
152 FDKsyncCache (bs);
153
154 pRvlc->bitstreamIndexRvlFwd = FDKgetBitCnt(bs); /* first bit within RVL coded block as start address for forward decoding */
155 pRvlc->bitstreamIndexRvlBwd = FDKgetBitCnt(bs) + pRvlc->length_of_rvlc_sf - 1; /* last bit within RVL coded block as start address for backward decoding */
156
157 /* skip RVLC-bitstream-part -- pointing now to escapes (if present) or to TNS data (if present) */
158 FDKpushFor (bs, pRvlc->length_of_rvlc_sf);
159
160 if ( pRvlc->sf_escapes_present != 0 ) {
161
162 /* locate internal bitstream ptr at escapes (which is the second part) */
163 FDKsyncCache (bs);
164 pRvlc->bitstreamIndexEsc = FDKgetBitCnt(bs);
165
166 /* skip escapeRVLC-bitstream-part -- pointing to TNS data (if present) to make decoder continue */
167 /* decoding of RVLC should work despite this second pushFor during initialization because */
168 /* bitstream initialization is valid for both ESC2 data parts (RVL-coded values and ESC-coded values) */
169 FDKpushFor (bs, pRvlc->length_of_rvlc_escapes);
170 }
171
172 #if VERBOSE_RVLC_INIT
173 DebugOutputInit(pRvlc,pAacDecoderChannelInfo);
174 #endif
175 }
176
177
178 /*---------------------------------------------------------------------------------------------
179 function: rvlcCheckIntensityCb
180
181 description: Check if a intensity codebook is used in the current channel.
182 -----------------------------------------------------------------------------------------------
183 input: - pointer rvlc structure
184 - pointer channel info structure
185 -----------------------------------------------------------------------------------------------
186 output: - intensity_used: 0 no intensity codebook is used
187 1 intensity codebook is used
188 -----------------------------------------------------------------------------------------------
189 return: -
190 -------------------------------------------------------------------------------------------- */
191
192 static
rvlcCheckIntensityCb(CErRvlcInfo * pRvlc,CAacDecoderChannelInfo * pAacDecoderChannelInfo)193 void rvlcCheckIntensityCb (CErRvlcInfo *pRvlc,
194 CAacDecoderChannelInfo *pAacDecoderChannelInfo)
195 {
196 int group, band, bnds;
197
198 pRvlc->intensity_used = 0;
199
200 for (group=0; group < pRvlc->numWindowGroups; group++) {
201 for (band=0; band < pRvlc->maxSfbTransmitted; band++) {
202 bnds = 16*group+band;
203 if ( (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds] == INTENSITY_HCB) || (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds] == INTENSITY_HCB2) ) {
204 pRvlc->intensity_used = 1;
205 break;
206 }
207 }
208 }
209 }
210
211
212 /*---------------------------------------------------------------------------------------------
213 function: rvlcDecodeEscapeWord
214
215 description: Decode a huffman coded RVLC Escape-word. This value is part of a DPCM coded
216 scalefactor.
217 -----------------------------------------------------------------------------------------------
218 input: - pointer rvlc structure
219 -----------------------------------------------------------------------------------------------
220 return: - a single RVLC-Escape value which had to be applied to a DPCM value (which
221 has a absolute value of 7)
222 -------------------------------------------------------------------------------------------- */
223
224 static
rvlcDecodeEscapeWord(CErRvlcInfo * pRvlc,HANDLE_FDK_BITSTREAM bs)225 SCHAR rvlcDecodeEscapeWord (CErRvlcInfo *pRvlc,
226 HANDLE_FDK_BITSTREAM bs)
227 {
228 int i;
229 SCHAR value;
230 UCHAR carryBit;
231 UINT treeNode;
232 UINT branchValue;
233 UINT branchNode;
234
235 USHORT* pBitstreamIndexEsc;
236 const UINT* pEscTree;
237
238 pEscTree = pRvlc->pHuffTreeRvlcEscape;
239 pBitstreamIndexEsc = &(pRvlc->bitstreamIndexEsc);
240 treeNode = *pEscTree; /* init at starting node */
241
242 for (i=MAX_LEN_RVLC_ESCAPE_WORD-1; i >= 0; i--) {
243 carryBit = rvlcReadBitFromBitstream(bs, /* get next bit */
244 pBitstreamIndexEsc,
245 FWD);
246
247 CarryBitToBranchValue(carryBit, /* huffman decoding, do a single step in huffman decoding tree */
248 treeNode,
249 &branchValue,
250 &branchNode);
251
252 if ((branchNode & TEST_BIT_10) == TEST_BIT_10) { /* test bit 10 ; if set --> a RVLC-escape-word is completely decoded */
253 value = (SCHAR) branchNode & CLR_BIT_10;
254 pRvlc->length_of_rvlc_escapes -= (MAX_LEN_RVLC_ESCAPE_WORD - i);
255
256 if (pRvlc->length_of_rvlc_escapes < 0) {
257 pRvlc->errorLogRvlc |= RVLC_ERROR_ALL_ESCAPE_WORDS_INVALID;
258 value = -1;
259 }
260
261 return value;
262 }
263 else {
264 treeNode = *(pEscTree + branchValue); /* update treeNode for further step in decoding tree */
265 }
266 }
267
268 pRvlc->errorLogRvlc |= RVLC_ERROR_ALL_ESCAPE_WORDS_INVALID;
269
270 return -1; /* should not be reached */
271 }
272
273
274 /*---------------------------------------------------------------------------------------------
275 function: rvlcDecodeEscapes
276
277 description: Decodes all huffman coded RVLC Escape Words.
278 Here a difference to the pseudo-code-implementation from standard can be
279 found. A while loop (and not two nested for loops) is used for two reasons:
280
281 1. The plain huffman encoded escapes are decoded before the RVL-coded
282 scalefactors. Therefore the escapes are present in the second step
283 when decoding the RVL-coded-scalefactor values in forward and
284 backward direction.
285
286 When the RVL-coded scalefactors are decoded and there a escape is
287 needed, then it is just taken out of the array in ascending order.
288
289 2. It's faster.
290 -----------------------------------------------------------------------------------------------
291 input: - pointer rvlc structure
292 - handle to FDK bitstream
293 -----------------------------------------------------------------------------------------------
294 return: - 0 ok the decoded escapes seem to be valid
295 - 1 error there was a error detected during decoding escapes
296 --> all escapes are invalid
297 -------------------------------------------------------------------------------------------- */
298
299 static
rvlcDecodeEscapes(CErRvlcInfo * pRvlc,SHORT * pEsc,HANDLE_FDK_BITSTREAM bs)300 void rvlcDecodeEscapes (CErRvlcInfo *pRvlc,
301 SHORT *pEsc,
302 HANDLE_FDK_BITSTREAM bs)
303 {
304 SCHAR escWord;
305 SCHAR escCnt=0;
306 SHORT* pEscBitCntSum;
307
308 pEscBitCntSum = &(pRvlc->length_of_rvlc_escapes);
309
310 /* Decode all RVLC-Escape words with a plain Huffman-Decoder */
311 while ( *pEscBitCntSum > 0 ) {
312 escWord = rvlcDecodeEscapeWord(pRvlc, bs);
313
314 if (escWord >= 0) {
315
316 pEsc[escCnt] = escWord;
317 escCnt++;
318 }
319 else {
320 pRvlc->errorLogRvlc |= RVLC_ERROR_ALL_ESCAPE_WORDS_INVALID;
321 pRvlc->numDecodedEscapeWordsEsc = escCnt;
322
323 return;
324 }
325 } /* all RVLC escapes decoded */
326
327 pRvlc->numDecodedEscapeWordsEsc = escCnt;
328 }
329
330
331 /*---------------------------------------------------------------------------------------------
332 function: decodeRVLCodeword
333
334 description: Decodes a RVL-coded dpcm-word (-part).
335 -----------------------------------------------------------------------------------------------
336 input: - FDK bitstream handle
337 - pointer rvlc structure
338 -----------------------------------------------------------------------------------------------
339 return: - a dpcm value which is within range [0,1,..,14] in case of no errors.
340 The offset of 7 must be subtracted to get a valid dpcm scalefactor value.
341 In case of errors a forbidden codeword is detected --> returning -1
342 -------------------------------------------------------------------------------------------- */
343
decodeRVLCodeword(HANDLE_FDK_BITSTREAM bs,CErRvlcInfo * pRvlc)344 SCHAR decodeRVLCodeword (HANDLE_FDK_BITSTREAM bs, CErRvlcInfo *pRvlc)
345 {
346 int i;
347 SCHAR value;
348 UCHAR carryBit;
349 UINT branchValue;
350 UINT branchNode;
351
352 const UINT *pRvlCodeTree = pRvlc->pHuffTreeRvlCodewds;
353 UCHAR direction = pRvlc->direction;
354 USHORT *pBitstrIndxRvl = pRvlc->pBitstrIndxRvl_RVL;
355 UINT treeNode = *pRvlCodeTree;
356
357 for (i=MAX_LEN_RVLC_CODE_WORD-1; i >= 0; i--) {
358 carryBit = rvlcReadBitFromBitstream(bs, /* get next bit */
359 pBitstrIndxRvl,
360 direction);
361
362 CarryBitToBranchValue(carryBit, /* huffman decoding, do a single step in huffman decoding tree */
363 treeNode,
364 &branchValue,
365 &branchNode);
366
367 if ((branchNode & TEST_BIT_10) == TEST_BIT_10) { /* test bit 10 ; if set --> a RVLC-codeword is completely decoded */
368 value = (SCHAR) (branchNode & CLR_BIT_10);
369 *pRvlc->pRvlBitCnt_RVL -= (MAX_LEN_RVLC_CODE_WORD - i);
370
371 /* check available bits for decoding */
372 if (*pRvlc->pRvlBitCnt_RVL < 0) {
373 if (direction == FWD) {
374 pRvlc->errorLogRvlc |= RVLC_ERROR_RVL_SUM_BIT_COUNTER_BELOW_ZERO_FWD; }
375 else {
376 pRvlc->errorLogRvlc |= RVLC_ERROR_RVL_SUM_BIT_COUNTER_BELOW_ZERO_BWD; }
377 value = -1; /* signalize an error in return value, because too many bits was decoded */
378 }
379
380 /* check max value of dpcm value */
381 if (value > MAX_ALLOWED_DPCM_INDEX) {
382 if (direction == FWD) {
383 pRvlc->errorLogRvlc |= RVLC_ERROR_FORBIDDEN_CW_DETECTED_FWD;
384 }
385 else {
386 pRvlc->errorLogRvlc |= RVLC_ERROR_FORBIDDEN_CW_DETECTED_BWD;
387 }
388 value = -1; /* signalize an error in return value, because a forbidden cw was detected*/
389 }
390
391 return value; /* return a dpcm value with offset +7 or an error status */
392 }
393 else {
394 treeNode = *(pRvlCodeTree + branchValue); /* update treeNode for further step in decoding tree */
395 }
396 }
397
398 return -1;
399 }
400
401
402 /*---------------------------------------------------------------------------------------------
403 function: rvlcDecodeForward
404
405 description: Decode RVL-coded codewords in forward direction.
406 -----------------------------------------------------------------------------------------------
407 input: - pointer rvlc structure
408 - pointer channel info structure
409 - handle to FDK bitstream
410 -----------------------------------------------------------------------------------------------
411 return: -
412 -------------------------------------------------------------------------------------------- */
413
414 static
rvlcDecodeForward(CErRvlcInfo * pRvlc,CAacDecoderChannelInfo * pAacDecoderChannelInfo,HANDLE_FDK_BITSTREAM bs)415 void rvlcDecodeForward (CErRvlcInfo *pRvlc,
416 CAacDecoderChannelInfo *pAacDecoderChannelInfo,
417 HANDLE_FDK_BITSTREAM bs)
418 {
419 int band = 0;
420 int group = 0;
421 int bnds = 0;
422
423 SHORT dpcm;
424
425 SHORT factor = pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain - SF_OFFSET;
426 SHORT position = - SF_OFFSET;
427 SHORT noisenrg = pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain - SF_OFFSET - 90 - 256;
428
429 SHORT* pScfFwd = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd;
430 SHORT* pScfEsc = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfEsc;
431 UCHAR* pEscFwdCnt = &(pRvlc->numDecodedEscapeWordsFwd);
432
433 pRvlc->pRvlBitCnt_RVL = &(pRvlc->length_of_rvlc_sf_fwd);
434 pRvlc->pBitstrIndxRvl_RVL = &(pRvlc->bitstreamIndexRvlFwd);
435
436 *pEscFwdCnt = 0;
437 pRvlc->direction = FWD;
438 pRvlc->noise_used = 0;
439 pRvlc->sf_used = 0;
440 pRvlc->lastScf = 0;
441 pRvlc->lastNrg = 0;
442 pRvlc->lastIs = 0;
443
444 rvlcCheckIntensityCb(pRvlc,pAacDecoderChannelInfo);
445
446 /* main loop fwd long */
447 for (group=0; group < pRvlc->numWindowGroups; group++) {
448 for (band=0; band < pRvlc->maxSfbTransmitted; band++) {
449 bnds = 16*group+band;
450
451 switch (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds]) {
452
453 case ZERO_HCB :
454 pScfFwd[bnds] = 0;
455 break;
456
457 case INTENSITY_HCB2 :
458 case INTENSITY_HCB :
459 /* store dpcm_is_position */
460 dpcm = decodeRVLCodeword(bs, pRvlc);
461 if ( dpcm < 0 ) {
462 pRvlc->conceal_max = bnds;
463 return;
464 }
465 dpcm -= TABLE_OFFSET;
466 if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
467 if (pRvlc->length_of_rvlc_escapes) {
468 pRvlc->conceal_max = bnds;
469 return;
470 }
471 else {
472 if (dpcm == MIN_RVL) {
473 dpcm -= *pScfEsc++;
474 }
475 else {
476 dpcm += *pScfEsc++;
477 }
478 (*pEscFwdCnt)++;
479 if (pRvlc->conceal_max_esc == CONCEAL_MAX_INIT) {
480 pRvlc->conceal_max_esc = bnds;
481 }
482 }
483 }
484 position += dpcm;
485 pScfFwd[bnds] = position;
486 pRvlc->lastIs = position;
487 break;
488
489 case NOISE_HCB :
490 if (pRvlc->noise_used == 0) {
491 pRvlc->noise_used = 1;
492 pRvlc->first_noise_band = bnds;
493 noisenrg += pRvlc->dpcm_noise_nrg;
494 pScfFwd[bnds] = 100 + noisenrg;
495 pRvlc->lastNrg = noisenrg;
496 }
497 else {
498 dpcm = decodeRVLCodeword(bs, pRvlc);
499 if ( dpcm < 0 ) {
500 pRvlc->conceal_max = bnds;
501 return;
502 }
503 dpcm -= TABLE_OFFSET;
504 if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
505 if (pRvlc->length_of_rvlc_escapes) {
506 pRvlc->conceal_max = bnds;
507 return;
508 }
509 else {
510 if (dpcm == MIN_RVL) {
511 dpcm -= *pScfEsc++;
512 }
513 else {
514 dpcm += *pScfEsc++;
515 }
516 (*pEscFwdCnt)++;
517 if (pRvlc->conceal_max_esc == CONCEAL_MAX_INIT) {
518 pRvlc->conceal_max_esc = bnds;
519 }
520 }
521 }
522 noisenrg += dpcm;
523 pScfFwd[bnds] = 100 + noisenrg;
524 pRvlc->lastNrg = noisenrg;
525 }
526 pAacDecoderChannelInfo->data.aac.PnsData.pnsUsed[bnds] = 1;
527 break ;
528
529 default :
530 pRvlc->sf_used = 1;
531 dpcm = decodeRVLCodeword(bs, pRvlc);
532 if ( dpcm < 0 ) {
533 pRvlc->conceal_max = bnds;
534 return;
535 }
536 dpcm -= TABLE_OFFSET;
537 if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
538 if (pRvlc->length_of_rvlc_escapes) {
539 pRvlc->conceal_max = bnds;
540 return;
541 }
542 else {
543 if (dpcm == MIN_RVL) {
544 dpcm -= *pScfEsc++; }
545 else {
546 dpcm += *pScfEsc++;
547 }
548 (*pEscFwdCnt)++;
549 if (pRvlc->conceal_max_esc == CONCEAL_MAX_INIT) {
550 pRvlc->conceal_max_esc = bnds;
551 }
552 }
553 }
554 factor += dpcm;
555 pScfFwd[bnds] = factor;
556 pRvlc->lastScf = factor;
557 break;
558 }
559 }
560 }
561
562 /* postfetch fwd long */
563 if (pRvlc->intensity_used) {
564 dpcm = decodeRVLCodeword(bs, pRvlc); /* dpcm_is_last_position */
565 if ( dpcm < 0 ) {
566 pRvlc->conceal_max = bnds;
567 return;
568 }
569 dpcm -= TABLE_OFFSET;
570 if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
571 if (pRvlc->length_of_rvlc_escapes) {
572 pRvlc->conceal_max = bnds;
573 return;
574 }
575 else {
576 if (dpcm == MIN_RVL) {
577 dpcm -= *pScfEsc++;
578 }
579 else {
580 dpcm += *pScfEsc++;
581 }
582 (*pEscFwdCnt)++;
583 if (pRvlc->conceal_max_esc == CONCEAL_MAX_INIT) {
584 pRvlc->conceal_max_esc = bnds;
585 }
586 }
587 }
588 pRvlc->dpcm_is_last_position = dpcm;
589 }
590 }
591
592
593 /*---------------------------------------------------------------------------------------------
594 function: rvlcDecodeBackward
595
596 description: Decode RVL-coded codewords in backward direction.
597 -----------------------------------------------------------------------------------------------
598 input: - pointer rvlc structure
599 - pointer channel info structure
600 - handle FDK bitstream
601 -----------------------------------------------------------------------------------------------
602 return: -
603 -------------------------------------------------------------------------------------------- */
604
605 static
rvlcDecodeBackward(CErRvlcInfo * pRvlc,CAacDecoderChannelInfo * pAacDecoderChannelInfo,HANDLE_FDK_BITSTREAM bs)606 void rvlcDecodeBackward (CErRvlcInfo *pRvlc,
607 CAacDecoderChannelInfo *pAacDecoderChannelInfo,
608 HANDLE_FDK_BITSTREAM bs)
609 {
610 SHORT band, group, dpcm, offset;
611 SHORT bnds = pRvlc->maxSfbTransmitted-1;
612
613 SHORT factor = pRvlc->rev_global_gain - SF_OFFSET;
614 SHORT position = pRvlc->dpcm_is_last_position - SF_OFFSET;
615 SHORT noisenrg = pRvlc->rev_global_gain + pRvlc->dpcm_noise_last_position - SF_OFFSET - 90 - 256;
616
617 SHORT *pScfBwd = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfBwd;
618 SHORT *pScfEsc = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfEsc;
619 UCHAR *pEscEscCnt = &(pRvlc->numDecodedEscapeWordsEsc);
620 UCHAR *pEscBwdCnt = &(pRvlc->numDecodedEscapeWordsBwd);
621
622 pRvlc->pRvlBitCnt_RVL = &(pRvlc->length_of_rvlc_sf_bwd);
623 pRvlc->pBitstrIndxRvl_RVL = &(pRvlc->bitstreamIndexRvlBwd);
624
625 *pEscBwdCnt = 0;
626 pRvlc->direction = BWD;
627 pScfEsc += *pEscEscCnt - 1; /* set pScfEsc to last entry */
628 pRvlc->firstScf = 0;
629 pRvlc->firstNrg = 0;
630 pRvlc->firstIs = 0;
631
632 /* prefetch long BWD */
633 if (pRvlc->intensity_used) {
634 dpcm = decodeRVLCodeword(bs, pRvlc); /* dpcm_is_last_position */
635 if ( dpcm < 0 ) {
636 pRvlc->dpcm_is_last_position = 0;
637 pRvlc->conceal_min = bnds;
638 return;
639 }
640 dpcm -= TABLE_OFFSET;
641 if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
642 if (pRvlc->length_of_rvlc_escapes) {
643 pRvlc->conceal_min = bnds;
644 return;
645 }
646 else {
647 if (dpcm == MIN_RVL) {
648 dpcm -= *pScfEsc--;
649 }
650 else {
651 dpcm += *pScfEsc--;
652 }
653 (*pEscBwdCnt)++;
654 if (pRvlc->conceal_min_esc == CONCEAL_MIN_INIT) {
655 pRvlc->conceal_min_esc = bnds;
656 }
657 }
658 }
659 pRvlc->dpcm_is_last_position = dpcm;
660 }
661
662 /* main loop long BWD */
663 for (group=pRvlc->numWindowGroups-1; group >= 0; group--) {
664 for (band=pRvlc->maxSfbTransmitted-1; band >= 0; band--) {
665 bnds = 16*group+band;
666 if ((band == 0) && (pRvlc->numWindowGroups != 1))
667 offset = 16 - pRvlc->maxSfbTransmitted + 1;
668 else
669 offset = 1;
670
671 switch (pAacDecoderChannelInfo->pDynData->aCodeBook[bnds]) {
672
673 case ZERO_HCB :
674 pScfBwd[bnds] = 0;
675 break;
676
677 case INTENSITY_HCB2 :
678 case INTENSITY_HCB :
679 /* store dpcm_is_position */
680 dpcm = decodeRVLCodeword(bs, pRvlc);
681 if ( dpcm < 0 ) {
682 pScfBwd[bnds] = position;
683 pRvlc->conceal_min = FDKmax(0,bnds-offset);
684 return;
685 }
686 dpcm -= TABLE_OFFSET;
687 if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
688 if (pRvlc->length_of_rvlc_escapes) {
689 pScfBwd[bnds] = position;
690 pRvlc->conceal_min = FDKmax(0,bnds-offset);
691 return;
692 }
693 else {
694 if (dpcm == MIN_RVL) {
695 dpcm -= *pScfEsc--;
696 }
697 else {
698 dpcm += *pScfEsc--;
699 }
700 (*pEscBwdCnt)++;
701 if (pRvlc->conceal_min_esc == CONCEAL_MIN_INIT) {
702 pRvlc->conceal_min_esc = FDKmax(0,bnds-offset);
703 }
704 }
705 }
706 pScfBwd[bnds] = position;
707 position -= dpcm;
708 pRvlc->firstIs = position;
709 break;
710
711 case NOISE_HCB :
712 if ( bnds == pRvlc->first_noise_band ) {
713 pScfBwd[bnds] = pRvlc->dpcm_noise_nrg + pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain - SF_OFFSET - 90 - 256;
714 pRvlc->firstNrg = pScfBwd[bnds];
715 }
716 else {
717 dpcm = decodeRVLCodeword(bs, pRvlc);
718 if ( dpcm < 0 ) {
719 pScfBwd[bnds] = noisenrg;
720 pRvlc->conceal_min = FDKmax(0,bnds-offset);
721 return;
722 }
723 dpcm -= TABLE_OFFSET;
724 if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
725 if (pRvlc->length_of_rvlc_escapes) {
726 pScfBwd[bnds] = noisenrg;
727 pRvlc->conceal_min = FDKmax(0,bnds-offset);
728 return;
729 }
730 else {
731 if (dpcm == MIN_RVL) {
732 dpcm -= *pScfEsc--;
733 }
734 else {
735 dpcm += *pScfEsc--;
736 }
737 (*pEscBwdCnt)++;
738 if (pRvlc->conceal_min_esc == CONCEAL_MIN_INIT) {
739 pRvlc->conceal_min_esc = FDKmax(0,bnds-offset);
740 }
741 }
742 }
743 pScfBwd[bnds] = noisenrg;
744 noisenrg -= dpcm;
745 pRvlc->firstNrg = noisenrg;
746 }
747 break ;
748
749 default :
750 dpcm = decodeRVLCodeword(bs, pRvlc);
751 if ( dpcm < 0 ) {
752 pScfBwd[bnds] = factor;
753 pRvlc->conceal_min = FDKmax(0,bnds-offset);
754 return;
755 }
756 dpcm -= TABLE_OFFSET;
757 if ((dpcm == MIN_RVL) || (dpcm == MAX_RVL)) {
758 if (pRvlc->length_of_rvlc_escapes) {
759 pScfBwd[bnds] = factor;
760 pRvlc->conceal_min = FDKmax(0,bnds-offset);
761 return;
762 }
763 else {
764 if (dpcm == MIN_RVL) {
765 dpcm -= *pScfEsc--;
766 }
767 else {
768 dpcm += *pScfEsc--;
769 }
770 (*pEscBwdCnt)++;
771 if (pRvlc->conceal_min_esc == CONCEAL_MIN_INIT) {
772 pRvlc->conceal_min_esc = FDKmax(0,bnds-offset);
773 }
774 }
775 }
776 pScfBwd[bnds] = factor;
777 factor -= dpcm;
778 pRvlc->firstScf = factor;
779 break;
780 }
781 }
782 }
783 }
784
785
786 /*---------------------------------------------------------------------------------------------
787 function: rvlcFinalErrorDetection
788
789 description: Call RVLC concealment if error was detected in decoding process
790 -----------------------------------------------------------------------------------------------
791 input: - pointer rvlc structure
792 - pointer channel info structure
793 -----------------------------------------------------------------------------------------------
794 return: -
795 -------------------------------------------------------------------------------------------- */
796
797 static
rvlcFinalErrorDetection(CAacDecoderChannelInfo * pAacDecoderChannelInfo,CAacDecoderStaticChannelInfo * pAacDecoderStaticChannelInfo)798 void rvlcFinalErrorDetection (CAacDecoderChannelInfo *pAacDecoderChannelInfo,
799 CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo)
800 {
801 CErRvlcInfo *pRvlc = &pAacDecoderChannelInfo->pComData->overlay.aac.erRvlcInfo;
802 UCHAR ErrorStatusComplete = 0;
803 UCHAR ErrorStatusLengthFwd = 0;
804 UCHAR ErrorStatusLengthBwd = 0;
805 UCHAR ErrorStatusLengthEscapes = 0;
806 UCHAR ErrorStatusFirstScf = 0;
807 UCHAR ErrorStatusLastScf = 0;
808 UCHAR ErrorStatusFirstNrg = 0;
809 UCHAR ErrorStatusLastNrg = 0;
810 UCHAR ErrorStatusFirstIs = 0;
811 UCHAR ErrorStatusLastIs = 0;
812 UCHAR ErrorStatusForbiddenCwFwd = 0;
813 UCHAR ErrorStatusForbiddenCwBwd = 0;
814 UCHAR ErrorStatusNumEscapesFwd = 0;
815 UCHAR ErrorStatusNumEscapesBwd = 0;
816 UCHAR ConcealStatus = 1;
817 UCHAR currentBlockType; /* short: 0, not short: 1*/
818
819 #if VERBOSE_RVLC_OUTPUT
820 CHAR Strategy[60]="No";
821 SHORT conceal_max;
822 SHORT conceal_min;
823 #endif
824
825 pAacDecoderChannelInfo->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK = 1;
826
827 /* invalid escape words, bit counter unequal zero, forbidden codeword detected */
828 if (pRvlc->errorLogRvlc & RVLC_ERROR_FORBIDDEN_CW_DETECTED_FWD)
829 ErrorStatusForbiddenCwFwd = 1;
830
831 if (pRvlc->errorLogRvlc & RVLC_ERROR_FORBIDDEN_CW_DETECTED_BWD)
832 ErrorStatusForbiddenCwBwd = 1;
833
834 /* bit counter forward unequal zero */
835 if (pRvlc->length_of_rvlc_sf_fwd)
836 ErrorStatusLengthFwd = 1;
837
838 /* bit counter backward unequal zero */
839 if (pRvlc->length_of_rvlc_sf_bwd)
840 ErrorStatusLengthBwd = 1;
841
842 /* bit counter escape sequences unequal zero */
843 if (pRvlc->sf_escapes_present)
844 if (pRvlc->length_of_rvlc_escapes)
845 ErrorStatusLengthEscapes = 1;
846
847 if (pRvlc->sf_used) {
848 /* first decoded scf does not match to global gain in backward direction */
849 if (pRvlc->firstScf != (pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain - SF_OFFSET) )
850 ErrorStatusFirstScf = 1;
851
852 /* last decoded scf does not match to rev global gain in forward direction */
853 if (pRvlc->lastScf != (pRvlc->rev_global_gain - SF_OFFSET) )
854 ErrorStatusLastScf = 1;
855 }
856
857 if (pRvlc->noise_used) {
858 /* first decoded nrg does not match to dpcm_noise_nrg in backward direction */
859 if (pRvlc->firstNrg != (pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain + pRvlc->dpcm_noise_nrg - SF_OFFSET -90 - 256) )
860 ErrorStatusFirstNrg = 1;
861
862 /* last decoded nrg does not match to dpcm_noise_last_position in forward direction */
863 if (pRvlc->lastNrg != (pRvlc->rev_global_gain + pRvlc->dpcm_noise_last_position - SF_OFFSET - 90 - 256) )
864 ErrorStatusLastNrg = 1;
865 }
866
867 if (pRvlc->intensity_used) {
868 /* first decoded is position does not match in backward direction */
869 if (pRvlc->firstIs != (-SF_OFFSET) )
870 ErrorStatusFirstIs = 1;
871
872 /* last decoded is position does not match in forward direction */
873 if (pRvlc->lastIs != (pRvlc->dpcm_is_last_position - SF_OFFSET) )
874 ErrorStatusLastIs = 1;
875 }
876
877 /* decoded escapes and used escapes in forward direction do not fit */
878 if ((pRvlc->numDecodedEscapeWordsFwd != pRvlc->numDecodedEscapeWordsEsc) && (pRvlc->conceal_max == CONCEAL_MAX_INIT)) {
879 ErrorStatusNumEscapesFwd = 1;
880 }
881
882 /* decoded escapes and used escapes in backward direction do not fit */
883 if ((pRvlc->numDecodedEscapeWordsBwd != pRvlc->numDecodedEscapeWordsEsc) && (pRvlc->conceal_min == CONCEAL_MIN_INIT)) {
884 ErrorStatusNumEscapesBwd = 1;
885 }
886
887 #if VERBOSE_RVLC_OUTPUT
888 conceal_max = pRvlc->conceal_max;
889 conceal_min = pRvlc->conceal_min;
890 #endif
891
892 if ( ErrorStatusLengthEscapes
893 || (
894 ( (pRvlc->conceal_max == CONCEAL_MAX_INIT)
895 && (pRvlc->numDecodedEscapeWordsFwd != pRvlc->numDecodedEscapeWordsEsc)
896 && (ErrorStatusLastScf || ErrorStatusLastNrg || ErrorStatusLastIs) )
897
898 &&
899
900 ( (pRvlc->conceal_min == CONCEAL_MIN_INIT)
901 && (pRvlc->numDecodedEscapeWordsBwd != pRvlc->numDecodedEscapeWordsEsc)
902 && (ErrorStatusFirstScf || ErrorStatusFirstNrg || ErrorStatusFirstIs) )
903 )
904 || ( (pRvlc->conceal_max == CONCEAL_MAX_INIT)
905 && ((pRvlc->rev_global_gain - SF_OFFSET - pRvlc->lastScf) < -15)
906 )
907 || ( (pRvlc->conceal_min == CONCEAL_MIN_INIT)
908 && ((pAacDecoderChannelInfo->pDynData->RawDataInfo.GlobalGain - SF_OFFSET - pRvlc->firstScf) < -15)
909 )
910 ) {
911 if ((pRvlc->conceal_max == CONCEAL_MAX_INIT) || (pRvlc->conceal_min == CONCEAL_MIN_INIT)) {
912 pRvlc->conceal_max = 0;
913 pRvlc->conceal_min = FDKmax(0, (pRvlc->numWindowGroups-1)*16+pRvlc->maxSfbTransmitted-1);
914 }
915 else {
916 pRvlc->conceal_max = FDKmin(pRvlc->conceal_max,pRvlc->conceal_max_esc);
917 pRvlc->conceal_min = FDKmax(pRvlc->conceal_min,pRvlc->conceal_min_esc);
918 }
919 }
920
921 ErrorStatusComplete = ErrorStatusLastScf || ErrorStatusFirstScf || ErrorStatusLastNrg || ErrorStatusFirstNrg
922 || ErrorStatusLastIs || ErrorStatusFirstIs || ErrorStatusForbiddenCwFwd || ErrorStatusForbiddenCwBwd
923 || ErrorStatusLengthFwd || ErrorStatusLengthBwd || ErrorStatusLengthEscapes || ErrorStatusNumEscapesFwd
924 || ErrorStatusNumEscapesBwd;
925
926 currentBlockType = (GetWindowSequence(&pAacDecoderChannelInfo->icsInfo) == EightShortSequence) ? 0 : 1;
927
928
929 if (!ErrorStatusComplete) {
930 int band;
931 int group;
932 int bnds;
933 int lastSfbIndex;
934
935 lastSfbIndex = (pRvlc->numWindowGroups > 1) ? 16 : 64;
936
937 for (group=0; group < pRvlc->numWindowGroups; group++) {
938 for (band=0; band<pRvlc->maxSfbTransmitted; band++) {
939 bnds = 16*group+band;
940 pAacDecoderChannelInfo->pDynData->aScaleFactor[bnds] = pAacDecoderStaticChannelInfo->concealmentInfo.aRvlcPreviousScaleFactor[bnds] = pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfFwd[bnds];
941 }
942 }
943
944 for (group=0; group < pRvlc->numWindowGroups; group++)
945 {
946 for (band=0; band<pRvlc->maxSfbTransmitted; band++) {
947 bnds = 16*group+band;
948 pAacDecoderStaticChannelInfo->concealmentInfo.aRvlcPreviousCodebook[bnds] = pAacDecoderChannelInfo->pDynData->aCodeBook[bnds];
949 }
950 for (; band <lastSfbIndex; band++) {
951 bnds = 16*group+band;
952 FDK_ASSERT(bnds >= 0 && bnds < RVLC_MAX_SFB);
953 pAacDecoderStaticChannelInfo->concealmentInfo.aRvlcPreviousCodebook[bnds] = ZERO_HCB;
954 }
955 }
956 }
957 else {
958 int band;
959 int group;
960
961 /* A single bit error was detected in decoding of dpcm values. It also could be an error with more bits in decoding
962 of escapes and dpcm values whereby an illegal codeword followed not directly after the corrupted bits but just
963 after decoding some more (wrong) scalefactors. Use the smaller scalefactor from forward decoding, backward decoding
964 and previous frame. */
965 if ( ((pRvlc->conceal_min != CONCEAL_MIN_INIT) || (pRvlc->conceal_max != CONCEAL_MAX_INIT)) && (pRvlc->conceal_min <= pRvlc->conceal_max)
966 && (pAacDecoderStaticChannelInfo->concealmentInfo.rvlcPreviousBlockType == currentBlockType) && pAacDecoderStaticChannelInfo->concealmentInfo.rvlcPreviousScaleFactorOK
967 && pRvlc->sf_concealment && ConcealStatus )
968 {
969 BidirectionalEstimation_UseScfOfPrevFrameAsReference (pAacDecoderChannelInfo, pAacDecoderStaticChannelInfo);
970 ConcealStatus=0;
971 #if VERBOSE_RVLC_OUTPUT
972 FDKstrcpy(Strategy,"Yes (BidirectionalEstimation_UseScfOfPrevFrameAsReference)");
973 #endif
974 }
975
976 /* A single bit error was detected in decoding of dpcm values. It also could be an error with more bits in decoding
977 of escapes and dpcm values whereby an illegal codeword followed not directly after the corrupted bits but just
978 after decoding some more (wrong) scalefactors. Use the smaller scalefactor from forward and backward decoding. */
979 if ( (pRvlc->conceal_min <= pRvlc->conceal_max) && ((pRvlc->conceal_min != CONCEAL_MIN_INIT) || (pRvlc->conceal_max != CONCEAL_MAX_INIT))
980 && !(pAacDecoderStaticChannelInfo->concealmentInfo.rvlcPreviousScaleFactorOK && pRvlc->sf_concealment && (pAacDecoderStaticChannelInfo->concealmentInfo.rvlcPreviousBlockType == currentBlockType))
981 && ConcealStatus )
982 {
983 BidirectionalEstimation_UseLowerScfOfCurrentFrame (pAacDecoderChannelInfo);
984 ConcealStatus=0;
985 #if VERBOSE_RVLC_OUTPUT
986 FDKstrcpy(Strategy,"Yes (BidirectionalEstimation_UseLowerScfOfCurrentFrame)");
987 #endif
988 }
989
990 /* No errors were detected in decoding of escapes and dpcm values however the first and last value
991 of a group (is,nrg,sf) is incorrect */
992 if ( (pRvlc->conceal_min <= pRvlc->conceal_max) && ((ErrorStatusLastScf && ErrorStatusFirstScf)
993 || (ErrorStatusLastNrg && ErrorStatusFirstNrg) || (ErrorStatusLastIs && ErrorStatusFirstIs))
994 && !(ErrorStatusForbiddenCwFwd || ErrorStatusForbiddenCwBwd || ErrorStatusLengthEscapes ) && ConcealStatus)
995 {
996 StatisticalEstimation (pAacDecoderChannelInfo);
997 ConcealStatus=0;
998 #if VERBOSE_RVLC_OUTPUT
999 FDKstrcpy(Strategy,"Yes (StatisticalEstimation)");
1000 #endif
1001 }
1002
1003 /* A error with more bits in decoding of escapes and dpcm values was detected. Use the smaller scalefactor from forward
1004 decoding, backward decoding and previous frame. */
1005 if ( (pRvlc->conceal_min <= pRvlc->conceal_max) && pAacDecoderStaticChannelInfo->concealmentInfo.rvlcPreviousScaleFactorOK && pRvlc->sf_concealment
1006 && (pAacDecoderStaticChannelInfo->concealmentInfo.rvlcPreviousBlockType == currentBlockType) && ConcealStatus )
1007 {
1008 PredictiveInterpolation(pAacDecoderChannelInfo, pAacDecoderStaticChannelInfo);
1009 ConcealStatus=0;
1010 #if VERBOSE_RVLC_OUTPUT
1011 FDKstrcpy(Strategy,"Yes (PredictiveInterpolation)");
1012 #endif
1013 }
1014
1015 /* Call frame concealment, because no better strategy was found. Setting the scalefactors to zero is done for debugging
1016 purposes */
1017 if (ConcealStatus) {
1018 for (group=0; group < pRvlc->numWindowGroups; group++) {
1019 for (band=0; band<pRvlc->maxSfbTransmitted; band++) {
1020 pAacDecoderChannelInfo->pDynData->aScaleFactor[16*group+band] = 0;
1021 }
1022 }
1023 pAacDecoderChannelInfo->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK = 0;
1024 #if VERBOSE_RVLC_OUTPUT
1025 FDKstrcpy(Strategy,"Yes (FrameConcealment)");
1026 #endif
1027 }
1028 }
1029
1030 #if VERBOSE_RVLC_OUTPUT
1031 DebugOutputDistortedBitstreams(pRvlc,pAacDecoderChannelInfo,ErrorStatusLengthFwd,ErrorStatusLengthBwd,
1032 ErrorStatusLengthEscapes,ErrorStatusFirstScf,ErrorStatusLastScf,
1033 ErrorStatusFirstNrg,ErrorStatusLastNrg,ErrorStatusFirstIs,ErrorStatusLastIs,
1034 ErrorStatusForbiddenCwFwd,ErrorStatusForbiddenCwBwd,ErrorStatusNumEscapesFwd,
1035 ErrorStatusNumEscapesBwd,conceal_max,conceal_min,Strategy);
1036 #endif
1037 }
1038
1039
1040 /*---------------------------------------------------------------------------------------------
1041 function: CRvlc_Read
1042
1043 description: Read RVLC ESC1 data (side info) from bitstream.
1044 -----------------------------------------------------------------------------------------------
1045 input: - pointer rvlc structure
1046 - pointer channel info structure
1047 - pointer bitstream structure
1048 -----------------------------------------------------------------------------------------------
1049 return: -
1050 -------------------------------------------------------------------------------------------- */
1051
CRvlc_Read(CAacDecoderChannelInfo * pAacDecoderChannelInfo,HANDLE_FDK_BITSTREAM bs)1052 void CRvlc_Read (
1053 CAacDecoderChannelInfo *pAacDecoderChannelInfo,
1054 HANDLE_FDK_BITSTREAM bs)
1055 {
1056 CErRvlcInfo *pRvlc = &pAacDecoderChannelInfo->pComData->overlay.aac.erRvlcInfo;
1057
1058 int group,band;
1059
1060 /* RVLC long specific initialization Init part 1 of 2 */
1061 pRvlc->numWindowGroups = GetWindowGroups(&pAacDecoderChannelInfo->icsInfo);
1062 pRvlc->maxSfbTransmitted = GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->icsInfo);
1063 pRvlc->noise_used = 0; /* noise detection */
1064 pRvlc->dpcm_noise_nrg = 0; /* only for debugging */
1065 pRvlc->dpcm_noise_last_position = 0; /* only for debugging */
1066 pRvlc->length_of_rvlc_escapes = -1; /* default value is used for error detection and concealment */
1067
1068 /* read only error sensitivity class 1 data (ESC 1 - data) */
1069 pRvlc->sf_concealment = FDKreadBits(bs,1); /* #1 */
1070 pRvlc->rev_global_gain = FDKreadBits(bs,8); /* #2 */
1071
1072 if (GetWindowSequence(&pAacDecoderChannelInfo->icsInfo) == EightShortSequence) {
1073 pRvlc->length_of_rvlc_sf = FDKreadBits(bs,11); /* #3 */
1074 }
1075 else {
1076 pRvlc->length_of_rvlc_sf = FDKreadBits(bs,9); /* #3 */
1077 }
1078
1079 /* check if noise codebook is used */
1080 for (group = 0; group < pRvlc->numWindowGroups; group++) {
1081 for (band=0; band < pRvlc->maxSfbTransmitted; band++) {
1082 if (pAacDecoderChannelInfo->pDynData->aCodeBook[16*group+band] == NOISE_HCB) {
1083 pRvlc->noise_used = 1;
1084 break;
1085 }
1086 }
1087 }
1088
1089 if (pRvlc->noise_used)
1090 pRvlc->dpcm_noise_nrg = FDKreadBits(bs, 9); /* #4 PNS */
1091
1092 pRvlc->sf_escapes_present = FDKreadBits(bs, 1); /* #5 */
1093
1094 if ( pRvlc->sf_escapes_present) {
1095 pRvlc->length_of_rvlc_escapes = FDKreadBits(bs, 8); /* #6 */
1096 }
1097
1098 if (pRvlc->noise_used) {
1099 pRvlc->dpcm_noise_last_position = FDKreadBits(bs, 9); /* #7 PNS */
1100 pRvlc->length_of_rvlc_sf -= 9;
1101 }
1102
1103 pRvlc->length_of_rvlc_sf_fwd = pRvlc->length_of_rvlc_sf;
1104 pRvlc->length_of_rvlc_sf_bwd = pRvlc->length_of_rvlc_sf;
1105 }
1106
1107
1108 /*---------------------------------------------------------------------------------------------
1109 function: CRvlc_Decode
1110
1111 description: Decode rvlc data
1112 The function reads both the escape sequences and the scalefactors in forward
1113 and backward direction. If an error occured during decoding process which can
1114 not be concealed with the rvlc concealment frame concealment will be initiated.
1115 Then the element "rvlcCurrentScaleFactorOK" in the decoder channel info is set
1116 to 0 otherwise it is set to 1.
1117 -----------------------------------------------------------------------------------------------
1118 input: - pointer rvlc structure
1119 - pointer channel info structure
1120 - pointer to persistent channel info structure
1121 - pointer bitstream structure
1122 -----------------------------------------------------------------------------------------------
1123 return: ErrorStatus = AAC_DEC_OK
1124 -------------------------------------------------------------------------------------------- */
1125
CRvlc_Decode(CAacDecoderChannelInfo * pAacDecoderChannelInfo,CAacDecoderStaticChannelInfo * pAacDecoderStaticChannelInfo,HANDLE_FDK_BITSTREAM bs)1126 void CRvlc_Decode (
1127 CAacDecoderChannelInfo *pAacDecoderChannelInfo,
1128 CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo,
1129 HANDLE_FDK_BITSTREAM bs
1130 )
1131 {
1132 CErRvlcInfo *pRvlc = &pAacDecoderChannelInfo->pComData->overlay.aac.erRvlcInfo;
1133 INT bitCntOffst;
1134 UINT saveBitCnt;
1135
1136 rvlcInit(pRvlc,pAacDecoderChannelInfo,bs);
1137
1138 /* save bitstream position */
1139 saveBitCnt = FDKgetBitCnt(bs);
1140
1141 #if RVLC_ADVANCED_BITSTREAM_ERROR_GENERATOR_SF
1142 GenerateSingleBitError(pRvlc,
1143 &(pRvlc->bitstreamIndexRvlFwd),
1144 pRvlc->length_of_rvlc_sf,
1145 0);
1146 #endif
1147
1148 #if RVLC_ADVANCED_BITSTREAM_ERROR_GENERATOR_ESC
1149 if (pRvlc->sf_escapes_present)
1150 GenerateSingleBitError(pRvlc,
1151 &(pRvlc->bitstreamIndexEsc),
1152 pRvlc->length_of_rvlc_escapes,
1153 1);
1154 #endif
1155
1156 if ( pRvlc->sf_escapes_present)
1157 rvlcDecodeEscapes(pRvlc, pAacDecoderChannelInfo->pComData->overlay.aac.aRvlcScfEsc, bs);
1158
1159 rvlcDecodeForward(pRvlc,pAacDecoderChannelInfo, bs);
1160 rvlcDecodeBackward(pRvlc,pAacDecoderChannelInfo, bs);
1161 rvlcFinalErrorDetection(pAacDecoderChannelInfo, pAacDecoderStaticChannelInfo);
1162
1163 pAacDecoderChannelInfo->pDynData->specificTo.aac.rvlcIntensityUsed = pRvlc->intensity_used;
1164 pAacDecoderChannelInfo->data.aac.PnsData.PnsActive = pRvlc->noise_used;
1165
1166 /* restore bitstream position */
1167 bitCntOffst = saveBitCnt - FDKgetBitCnt(bs);
1168 if( bitCntOffst ) {
1169 FDKpushBiDirectional(bs, bitCntOffst);
1170 }
1171 }
1172
CRvlc_ElementCheck(CAacDecoderChannelInfo * pAacDecoderChannelInfo[],CAacDecoderStaticChannelInfo * pAacDecoderStaticChannelInfo[],const UINT flags,const INT elChannels)1173 void CRvlc_ElementCheck (
1174 CAacDecoderChannelInfo *pAacDecoderChannelInfo[],
1175 CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo[],
1176 const UINT flags,
1177 const INT elChannels
1178 )
1179 {
1180 int ch;
1181
1182 /* Required for MPS residuals. */
1183 if (pAacDecoderStaticChannelInfo == NULL) {
1184 return;
1185 }
1186
1187 /* RVLC specific sanity checks */
1188 if ( (flags & AC_ER_RVLC) && (elChannels == 2)) { /* to be reviewed */
1189 if ( ( (pAacDecoderChannelInfo[0]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK == 0) ||
1190 (pAacDecoderChannelInfo[1]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK == 0) )
1191 && pAacDecoderChannelInfo[0]->pComData->jointStereoData.MsMaskPresent ) {
1192 pAacDecoderChannelInfo[0]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK = 0;
1193 pAacDecoderChannelInfo[1]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK = 0;
1194 }
1195
1196 if ( (pAacDecoderChannelInfo[0]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK == 0)
1197 && (pAacDecoderChannelInfo[1]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK == 1)
1198 && (pAacDecoderChannelInfo[1]->pDynData->specificTo.aac.rvlcIntensityUsed == 1) ){
1199 pAacDecoderChannelInfo[1]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK = 0;
1200 }
1201 }
1202
1203 for (ch = 0; ch < elChannels; ch ++)
1204 {
1205 pAacDecoderStaticChannelInfo[ch]->concealmentInfo.rvlcPreviousBlockType = (GetWindowSequence(&pAacDecoderChannelInfo[ch]->icsInfo) == EightShortSequence) ? 0 : 1;
1206 if (flags & AC_ER_RVLC) {
1207 pAacDecoderStaticChannelInfo[ch]->concealmentInfo.rvlcPreviousScaleFactorOK = pAacDecoderChannelInfo[ch]->pDynData->specificTo.aac.rvlcCurrentScaleFactorOK;
1208 }
1209 else {
1210 pAacDecoderStaticChannelInfo[ch]->concealmentInfo.rvlcPreviousScaleFactorOK = 0;
1211 }
1212 }
1213 }
1214
1215
1216