1 /* ----------------------------------------------------------------------------- 2 Software License for The Fraunhofer FDK AAC Codec Library for Android 3 4 Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Frderung 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 (at) iis.fraunhofer.de 93 ----------------------------------------------------------------------------- */ 94 95 /**************************** SBR decoder library ****************************** 96 97 Author(s): 98 99 Description: 100 101 *******************************************************************************/ 102 103 #include "psbitdec.h" 104 105 #include "sbr_rom.h" 106 #include "huff_dec.h" 107 108 /* PS dec privat functions */ 109 SBR_ERROR ResetPsDec(HANDLE_PS_DEC h_ps_d); 110 111 /***************************************************************************/ 112 /*! 113 \brief huffman decoding by codebook table 114 115 \return index of huffman codebook table 116 117 ****************************************************************************/ 118 static SCHAR decode_huff_cw( 119 Huffman h, /*!< pointer to huffman codebook table */ 120 HANDLE_FDK_BITSTREAM hBitBuf, /*!< Handle to Bitbuffer */ 121 int *length) /*!< length of huffman codeword (or NULL) */ 122 { 123 UCHAR bit = 0; 124 SCHAR index = 0; 125 UCHAR bitCount = 0; 126 127 while (index >= 0) { 128 bit = FDKreadBits(hBitBuf, 1); 129 bitCount++; 130 index = h[index][bit]; 131 } 132 if (length) { 133 *length = bitCount; 134 } 135 return (index + 64); /* Add offset */ 136 } 137 138 /***************************************************************************/ 139 /*! 140 \brief helper function - limiting of value to min/max values 141 142 \return limited value 143 144 ****************************************************************************/ 145 146 static SCHAR limitMinMax(SCHAR i, SCHAR min, SCHAR max) { 147 if (i < min) 148 return min; 149 else if (i > max) 150 return max; 151 else 152 return i; 153 } 154 155 /***************************************************************************/ 156 /*! 157 \brief Decodes delta values in-place and updates 158 data buffers according to quantization classes. 159 160 When delta coded in frequency the first element is deltacode from zero. 161 aIndex buffer is decoded from delta values to actual values. 162 163 \return none 164 165 ****************************************************************************/ 166 static void deltaDecodeArray( 167 SCHAR enable, SCHAR *aIndex, /*!< ICC/IID parameters */ 168 SCHAR *aPrevFrameIndex, /*!< ICC/IID parameters of previous frame */ 169 SCHAR DtDf, UCHAR nrElements, /*!< as conveyed in bitstream */ 170 /*!< output array size: nrElements*stride */ 171 UCHAR stride, /*!< 1=dflt, 2=half freq. resolution */ 172 SCHAR minIdx, SCHAR maxIdx) { 173 int i; 174 175 /* Delta decode */ 176 if (enable == 1) { 177 if (DtDf == 0) { /* Delta coded in freq */ 178 aIndex[0] = 0 + aIndex[0]; 179 aIndex[0] = limitMinMax(aIndex[0], minIdx, maxIdx); 180 for (i = 1; i < nrElements; i++) { 181 aIndex[i] = aIndex[i - 1] + aIndex[i]; 182 aIndex[i] = limitMinMax(aIndex[i], minIdx, maxIdx); 183 } 184 } else { /* Delta time */ 185 for (i = 0; i < nrElements; i++) { 186 aIndex[i] = aPrevFrameIndex[i * stride] + aIndex[i]; 187 aIndex[i] = limitMinMax(aIndex[i], minIdx, maxIdx); 188 } 189 } 190 } else { /* No data is sent, set index to zero */ 191 for (i = 0; i < nrElements; i++) { 192 aIndex[i] = 0; 193 } 194 } 195 if (stride == 2) { 196 for (i = nrElements * stride - 1; i > 0; i--) { 197 aIndex[i] = aIndex[i >> 1]; 198 } 199 } 200 } 201 202 /***************************************************************************/ 203 /*! 204 \brief Mapping of ICC/IID parameters to 20 stereo bands 205 206 \return none 207 208 ****************************************************************************/ 209 static void map34IndexTo20(SCHAR *aIndex, /*!< decoded ICC/IID parameters */ 210 UCHAR noBins) /*!< number of stereo bands */ 211 { 212 aIndex[0] = (2 * aIndex[0] + aIndex[1]) / 3; 213 aIndex[1] = (aIndex[1] + 2 * aIndex[2]) / 3; 214 aIndex[2] = (2 * aIndex[3] + aIndex[4]) / 3; 215 aIndex[3] = (aIndex[4] + 2 * aIndex[5]) / 3; 216 aIndex[4] = (aIndex[6] + aIndex[7]) / 2; 217 aIndex[5] = (aIndex[8] + aIndex[9]) / 2; 218 aIndex[6] = aIndex[10]; 219 aIndex[7] = aIndex[11]; 220 aIndex[8] = (aIndex[12] + aIndex[13]) / 2; 221 aIndex[9] = (aIndex[14] + aIndex[15]) / 2; 222 aIndex[10] = aIndex[16]; 223 /* For IPD/OPD it stops here */ 224 225 if (noBins == NO_HI_RES_BINS) { 226 aIndex[11] = aIndex[17]; 227 aIndex[12] = aIndex[18]; 228 aIndex[13] = aIndex[19]; 229 aIndex[14] = (aIndex[20] + aIndex[21]) / 2; 230 aIndex[15] = (aIndex[22] + aIndex[23]) / 2; 231 aIndex[16] = (aIndex[24] + aIndex[25]) / 2; 232 aIndex[17] = (aIndex[26] + aIndex[27]) / 2; 233 aIndex[18] = (aIndex[28] + aIndex[29] + aIndex[30] + aIndex[31]) / 4; 234 aIndex[19] = (aIndex[32] + aIndex[33]) / 2; 235 } 236 } 237 238 /***************************************************************************/ 239 /*! 240 \brief Decodes delta coded IID, ICC, IPD and OPD indices 241 242 \return PS processing flag. If set to 1 243 244 ****************************************************************************/ 245 int DecodePs(struct PS_DEC *h_ps_d, /*!< PS handle */ 246 const UCHAR frameError, /*!< Flag telling that frame had errors */ 247 PS_DEC_COEFFICIENTS *pScratch) { 248 MPEG_PS_BS_DATA *pBsData; 249 UCHAR gr, env; 250 int bPsHeaderValid, bPsDataAvail; 251 252 /* Assign Scratch */ 253 h_ps_d->specificTo.mpeg.pCoef = pScratch; 254 255 /* Shortcuts to avoid deferencing and keep the code readable */ 256 pBsData = &h_ps_d->bsData[h_ps_d->processSlot].mpeg; 257 bPsHeaderValid = pBsData->bPsHeaderValid; 258 bPsDataAvail = 259 (h_ps_d->bPsDataAvail[h_ps_d->processSlot] == ppt_mpeg) ? 1 : 0; 260 261 /*************************************************************************************** 262 * Decide whether to process or to conceal PS data or not. */ 263 264 if ((h_ps_d->psDecodedPrv && !frameError && !bPsDataAvail) || 265 (!h_ps_d->psDecodedPrv && 266 (frameError || !bPsDataAvail || !bPsHeaderValid))) { 267 /* Don't apply PS processing. 268 * Declare current PS header and bitstream data invalid. */ 269 pBsData->bPsHeaderValid = 0; 270 h_ps_d->bPsDataAvail[h_ps_d->processSlot] = ppt_none; 271 return (0); 272 } 273 274 if (frameError || 275 !bPsHeaderValid) { /* no new PS data available (e.g. frame loss) */ 276 /* => keep latest data constant (i.e. FIX with noEnv=0) */ 277 pBsData->noEnv = 0; 278 } 279 280 /*************************************************************************************** 281 * Decode bitstream payload or prepare parameter for concealment: 282 */ 283 for (env = 0; env < pBsData->noEnv; env++) { 284 SCHAR *aPrevIidIndex; 285 SCHAR *aPrevIccIndex; 286 287 UCHAR noIidSteps = pBsData->bFineIidQ ? NO_IID_STEPS_FINE : NO_IID_STEPS; 288 289 if (env == 0) { 290 aPrevIidIndex = h_ps_d->specificTo.mpeg.aIidPrevFrameIndex; 291 aPrevIccIndex = h_ps_d->specificTo.mpeg.aIccPrevFrameIndex; 292 } else { 293 aPrevIidIndex = pBsData->aaIidIndex[env - 1]; 294 aPrevIccIndex = pBsData->aaIccIndex[env - 1]; 295 } 296 297 deltaDecodeArray(pBsData->bEnableIid, pBsData->aaIidIndex[env], 298 aPrevIidIndex, pBsData->abIidDtFlag[env], 299 FDK_sbrDecoder_aNoIidBins[pBsData->freqResIid], 300 (pBsData->freqResIid) ? 1 : 2, -noIidSteps, noIidSteps); 301 302 deltaDecodeArray(pBsData->bEnableIcc, pBsData->aaIccIndex[env], 303 aPrevIccIndex, pBsData->abIccDtFlag[env], 304 FDK_sbrDecoder_aNoIccBins[pBsData->freqResIcc], 305 (pBsData->freqResIcc) ? 1 : 2, 0, NO_ICC_STEPS - 1); 306 } /* for (env=0; env<pBsData->noEnv; env++) */ 307 308 /* handling of FIX noEnv=0 */ 309 if (pBsData->noEnv == 0) { 310 /* set noEnv=1, keep last parameters or force 0 if not enabled */ 311 pBsData->noEnv = 1; 312 313 if (pBsData->bEnableIid) { 314 pBsData->bFineIidQ = h_ps_d->specificTo.mpeg.bPrevFrameFineIidQ; 315 for (gr = 0; gr < NO_HI_RES_IID_BINS; gr++) { 316 pBsData->aaIidIndex[pBsData->noEnv - 1][gr] = 317 h_ps_d->specificTo.mpeg.aIidPrevFrameIndex[gr]; 318 } 319 } else { 320 for (gr = 0; gr < NO_HI_RES_IID_BINS; gr++) { 321 pBsData->aaIidIndex[pBsData->noEnv - 1][gr] = 0; 322 } 323 } 324 325 if (pBsData->bEnableIcc) { 326 for (gr = 0; gr < NO_HI_RES_ICC_BINS; gr++) { 327 pBsData->aaIccIndex[pBsData->noEnv - 1][gr] = 328 h_ps_d->specificTo.mpeg.aIccPrevFrameIndex[gr]; 329 } 330 } else { 331 for (gr = 0; gr < NO_HI_RES_ICC_BINS; gr++) { 332 pBsData->aaIccIndex[pBsData->noEnv - 1][gr] = 0; 333 } 334 } 335 } 336 337 /* Update previous frame Iid quantization */ 338 h_ps_d->specificTo.mpeg.bPrevFrameFineIidQ = pBsData->bFineIidQ; 339 340 /* Update previous frame index buffers */ 341 for (gr = 0; gr < NO_HI_RES_IID_BINS; gr++) { 342 h_ps_d->specificTo.mpeg.aIidPrevFrameIndex[gr] = 343 pBsData->aaIidIndex[pBsData->noEnv - 1][gr]; 344 } 345 for (gr = 0; gr < NO_HI_RES_ICC_BINS; gr++) { 346 h_ps_d->specificTo.mpeg.aIccPrevFrameIndex[gr] = 347 pBsData->aaIccIndex[pBsData->noEnv - 1][gr]; 348 } 349 350 /* PS data from bitstream (if avail) was decoded now */ 351 h_ps_d->bPsDataAvail[h_ps_d->processSlot] = ppt_none; 352 353 /* handling of env borders for FIX & VAR */ 354 if (pBsData->bFrameClass == 0) { 355 /* FIX_BORDERS NoEnv=0,1,2,4 */ 356 pBsData->aEnvStartStop[0] = 0; 357 for (env = 1; env < pBsData->noEnv; env++) { 358 pBsData->aEnvStartStop[env] = 359 (env * h_ps_d->noSubSamples) / pBsData->noEnv; 360 } 361 pBsData->aEnvStartStop[pBsData->noEnv] = h_ps_d->noSubSamples; 362 /* 1024 (32 slots) env borders: 0, 8, 16, 24, 32 */ 363 /* 960 (30 slots) env borders: 0, 7, 15, 22, 30 */ 364 } else { /* if (h_ps_d->bFrameClass == 0) */ 365 /* VAR_BORDERS NoEnv=1,2,3,4 */ 366 pBsData->aEnvStartStop[0] = 0; 367 368 /* handle case aEnvStartStop[noEnv]<noSubSample for VAR_BORDERS by 369 duplicating last PS parameters and incrementing noEnv */ 370 if (pBsData->aEnvStartStop[pBsData->noEnv] < h_ps_d->noSubSamples) { 371 for (gr = 0; gr < NO_HI_RES_IID_BINS; gr++) { 372 pBsData->aaIidIndex[pBsData->noEnv][gr] = 373 pBsData->aaIidIndex[pBsData->noEnv - 1][gr]; 374 } 375 for (gr = 0; gr < NO_HI_RES_ICC_BINS; gr++) { 376 pBsData->aaIccIndex[pBsData->noEnv][gr] = 377 pBsData->aaIccIndex[pBsData->noEnv - 1][gr]; 378 } 379 pBsData->noEnv++; 380 pBsData->aEnvStartStop[pBsData->noEnv] = h_ps_d->noSubSamples; 381 } 382 383 /* enforce strictly monotonic increasing borders */ 384 for (env = 1; env < pBsData->noEnv; env++) { 385 UCHAR thr; 386 thr = (UCHAR)h_ps_d->noSubSamples - (pBsData->noEnv - env); 387 if (pBsData->aEnvStartStop[env] > thr) { 388 pBsData->aEnvStartStop[env] = thr; 389 } else { 390 thr = pBsData->aEnvStartStop[env - 1] + 1; 391 if (pBsData->aEnvStartStop[env] < thr) { 392 pBsData->aEnvStartStop[env] = thr; 393 } 394 } 395 } 396 } /* if (h_ps_d->bFrameClass == 0) ... else */ 397 398 /* copy data prior to possible 20<->34 in-place mapping */ 399 for (env = 0; env < pBsData->noEnv; env++) { 400 UCHAR i; 401 for (i = 0; i < NO_HI_RES_IID_BINS; i++) { 402 h_ps_d->specificTo.mpeg.pCoef->aaIidIndexMapped[env][i] = 403 pBsData->aaIidIndex[env][i]; 404 } 405 for (i = 0; i < NO_HI_RES_ICC_BINS; i++) { 406 h_ps_d->specificTo.mpeg.pCoef->aaIccIndexMapped[env][i] = 407 pBsData->aaIccIndex[env][i]; 408 } 409 } 410 411 /* MPEG baseline PS */ 412 /* Baseline version of PS always uses the hybrid filter structure with 20 413 * stereo bands. */ 414 /* If ICC/IID parameters for 34 stereo bands are decoded they have to be 415 * mapped to 20 */ 416 /* stereo bands. */ 417 /* Additionaly the IPD/OPD parameters won't be used. */ 418 419 for (env = 0; env < pBsData->noEnv; env++) { 420 if (pBsData->freqResIid == 2) 421 map34IndexTo20(h_ps_d->specificTo.mpeg.pCoef->aaIidIndexMapped[env], 422 NO_HI_RES_IID_BINS); 423 if (pBsData->freqResIcc == 2) 424 map34IndexTo20(h_ps_d->specificTo.mpeg.pCoef->aaIccIndexMapped[env], 425 NO_HI_RES_ICC_BINS); 426 427 /* IPD/OPD is disabled in baseline version and thus was removed here */ 428 } 429 430 return (1); 431 } 432 433 /***************************************************************************/ 434 /*! 435 436 \brief Reads parametric stereo data from bitstream 437 438 \return 439 440 ****************************************************************************/ 441 unsigned int ReadPsData( 442 HANDLE_PS_DEC h_ps_d, /*!< handle to struct PS_DEC */ 443 HANDLE_FDK_BITSTREAM hBitBuf, /*!< handle to struct BIT_BUF */ 444 int nBitsLeft /*!< max number of bits available */ 445 ) { 446 MPEG_PS_BS_DATA *pBsData; 447 448 UCHAR gr, env; 449 SCHAR dtFlag; 450 INT startbits; 451 Huffman CurrentTable; 452 SCHAR bEnableHeader; 453 454 if (!h_ps_d) return 0; 455 456 pBsData = &h_ps_d->bsData[h_ps_d->bsReadSlot].mpeg; 457 458 if (h_ps_d->bsReadSlot != h_ps_d->bsLastSlot) { 459 /* Copy last header data */ 460 FDKmemcpy(pBsData, &h_ps_d->bsData[h_ps_d->bsLastSlot].mpeg, 461 sizeof(MPEG_PS_BS_DATA)); 462 } 463 464 startbits = (INT)FDKgetValidBits(hBitBuf); 465 466 bEnableHeader = (SCHAR)FDKreadBits(hBitBuf, 1); 467 468 /* Read header */ 469 if (bEnableHeader) { 470 pBsData->bPsHeaderValid = 1; 471 pBsData->bEnableIid = (UCHAR)FDKreadBits(hBitBuf, 1); 472 if (pBsData->bEnableIid) { 473 pBsData->modeIid = (UCHAR)FDKreadBits(hBitBuf, 3); 474 } 475 476 pBsData->bEnableIcc = (UCHAR)FDKreadBits(hBitBuf, 1); 477 if (pBsData->bEnableIcc) { 478 pBsData->modeIcc = (UCHAR)FDKreadBits(hBitBuf, 3); 479 } 480 481 pBsData->bEnableExt = (UCHAR)FDKreadBits(hBitBuf, 1); 482 } 483 484 pBsData->bFrameClass = (UCHAR)FDKreadBits(hBitBuf, 1); 485 if (pBsData->bFrameClass == 0) { 486 /* FIX_BORDERS NoEnv=0,1,2,4 */ 487 pBsData->noEnv = 488 FDK_sbrDecoder_aFixNoEnvDecode[(UCHAR)FDKreadBits(hBitBuf, 2)]; 489 /* all additional handling of env borders is now in DecodePs() */ 490 } else { 491 /* VAR_BORDERS NoEnv=1,2,3,4 */ 492 pBsData->noEnv = 1 + (UCHAR)FDKreadBits(hBitBuf, 2); 493 for (env = 1; env < pBsData->noEnv + 1; env++) 494 pBsData->aEnvStartStop[env] = ((UCHAR)FDKreadBits(hBitBuf, 5)) + 1; 495 /* all additional handling of env borders is now in DecodePs() */ 496 } 497 498 /* verify that IID & ICC modes (quant grid, freq res) are supported */ 499 if ((pBsData->modeIid > 5) || (pBsData->modeIcc > 5)) { 500 /* no useful PS data could be read from bitstream */ 501 h_ps_d->bPsDataAvail[h_ps_d->bsReadSlot] = ppt_none; 502 /* discard all remaining bits */ 503 nBitsLeft -= startbits - (INT)FDKgetValidBits(hBitBuf); 504 while (nBitsLeft > 0) { 505 int i = nBitsLeft; 506 if (i > 8) { 507 i = 8; 508 } 509 FDKreadBits(hBitBuf, i); 510 nBitsLeft -= i; 511 } 512 return (UINT)(startbits - (INT)FDKgetValidBits(hBitBuf)); 513 } 514 515 if (pBsData->modeIid > 2) { 516 pBsData->freqResIid = pBsData->modeIid - 3; 517 pBsData->bFineIidQ = 1; 518 } else { 519 pBsData->freqResIid = pBsData->modeIid; 520 pBsData->bFineIidQ = 0; 521 } 522 523 if (pBsData->modeIcc > 2) { 524 pBsData->freqResIcc = pBsData->modeIcc - 3; 525 } else { 526 pBsData->freqResIcc = pBsData->modeIcc; 527 } 528 529 /* Extract IID data */ 530 if (pBsData->bEnableIid) { 531 for (env = 0; env < pBsData->noEnv; env++) { 532 dtFlag = (SCHAR)FDKreadBits(hBitBuf, 1); 533 if (!dtFlag) { 534 if (pBsData->bFineIidQ) 535 CurrentTable = (Huffman)&aBookPsIidFineFreqDecode; 536 else 537 CurrentTable = (Huffman)&aBookPsIidFreqDecode; 538 } else { 539 if (pBsData->bFineIidQ) 540 CurrentTable = (Huffman)&aBookPsIidFineTimeDecode; 541 else 542 CurrentTable = (Huffman)&aBookPsIidTimeDecode; 543 } 544 545 for (gr = 0; gr < FDK_sbrDecoder_aNoIidBins[pBsData->freqResIid]; gr++) 546 pBsData->aaIidIndex[env][gr] = 547 decode_huff_cw(CurrentTable, hBitBuf, NULL); 548 pBsData->abIidDtFlag[env] = dtFlag; 549 } 550 } 551 552 /* Extract ICC data */ 553 if (pBsData->bEnableIcc) { 554 for (env = 0; env < pBsData->noEnv; env++) { 555 dtFlag = (SCHAR)FDKreadBits(hBitBuf, 1); 556 if (!dtFlag) 557 CurrentTable = (Huffman)&aBookPsIccFreqDecode; 558 else 559 CurrentTable = (Huffman)&aBookPsIccTimeDecode; 560 561 for (gr = 0; gr < FDK_sbrDecoder_aNoIccBins[pBsData->freqResIcc]; gr++) 562 pBsData->aaIccIndex[env][gr] = 563 decode_huff_cw(CurrentTable, hBitBuf, NULL); 564 pBsData->abIccDtFlag[env] = dtFlag; 565 } 566 } 567 568 if (pBsData->bEnableExt) { 569 /*! 570 Decoders that support only the baseline version of the PS tool are allowed 571 to ignore the IPD/OPD data, but according header data has to be parsed. 572 ISO/IEC 14496-3 Subpart 8 Annex 4 573 */ 574 575 int cnt = FDKreadBits(hBitBuf, PS_EXTENSION_SIZE_BITS); 576 if (cnt == (1 << PS_EXTENSION_SIZE_BITS) - 1) { 577 cnt += FDKreadBits(hBitBuf, PS_EXTENSION_ESC_COUNT_BITS); 578 } 579 while (cnt--) FDKreadBits(hBitBuf, 8); 580 } 581 582 /* new PS data was read from bitstream */ 583 h_ps_d->bPsDataAvail[h_ps_d->bsReadSlot] = ppt_mpeg; 584 585 return (startbits - (INT)FDKgetValidBits(hBitBuf)); 586 } 587