1 2/* ----------------------------------------------------------------------------------------------------------- 3Software License for The Fraunhofer FDK AAC Codec Library for Android 4 5© Copyright 1995 - 2012 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V. 6 All rights reserved. 7 8 1. INTRODUCTION 9The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements 10the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio. 11This FDK AAC Codec software is intended to be used on a wide variety of Android devices. 12 13AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual 14audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by 15independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part 16of the MPEG specifications. 17 18Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer) 19may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners 20individually for the purpose of encoding or decoding bit streams in products that are compliant with 21the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license 22these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec 23software may already be covered under those patent licenses when it is used for those licensed purposes only. 24 25Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality, 26are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional 27applications information and documentation. 28 292. COPYRIGHT LICENSE 30 31Redistribution and use in source and binary forms, with or without modification, are permitted without 32payment of copyright license fees provided that you satisfy the following conditions: 33 34You must retain the complete text of this software license in redistributions of the FDK AAC Codec or 35your modifications thereto in source code form. 36 37You must retain the complete text of this software license in the documentation and/or other materials 38provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form. 39You must make available free of charge copies of the complete source code of the FDK AAC Codec and your 40modifications thereto to recipients of copies in binary form. 41 42The name of Fraunhofer may not be used to endorse or promote products derived from this library without 43prior written permission. 44 45You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec 46software or your modifications thereto. 47 48Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software 49and 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 533. NO PATENT LICENSE 54 55NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer, 56ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with 57respect to this software. 58 59You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized 60by appropriate patent licenses. 61 624. DISCLAIMER 63 64This 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 66of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 67CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages, 68including but not limited to procurement of substitute goods or services; loss of use, data, or profits, 69or business interruption, however caused and on any theory of liability, whether in contract, strict 70liability, or tort (including negligence), arising in any way out of the use of this software, even if 71advised of the possibility of such damage. 72 735. CONTACT INFORMATION 74 75Fraunhofer Institute for Integrated Circuits IIS 76Attention: Audio and Multimedia Departments - FDK AAC LL 77Am Wolfsmantel 33 7891058 Erlangen, Germany 79 80www.iis.fraunhofer.de/amm 81amm-info@iis.fraunhofer.de 82----------------------------------------------------------------------------------------------------------- */ 83 84/***************************** MPEG-4 AAC Decoder *************************** 85 86 Author(s): Robert Weidner (DSP Solutions) 87 Description: HCR Decoder: Prepare decoding of non-PCWs, segmentation- and 88 bitfield-handling, HCR-Statemachine 89 90*******************************************************************************/ 91 92#include "aacdec_hcrs.h" 93 94 95#include "aacdec_hcr.h" 96 97#include "aacdec_hcr_bit.h" 98#include "aac_rom.h" 99#include "aac_ram.h" 100 101 102static UINT InitSegmentBitfield(UINT *pNumSegment, 103 SCHAR *pRemainingBitsInSegment, 104 UINT *pSegmentBitfield, 105 UCHAR *pNumWordForBitfield, 106 USHORT *pNumBitValidInLastWord); 107 108static void InitNonPCWSideInformationForCurrentSet(H_HCR_INFO pHcr); 109 110static INT ModuloValue(INT input, INT bufferlength); 111 112static void ClearBitFromBitfield(STATEFUNC *ptrState, 113 UINT offset, 114 UINT *pBitfield); 115 116 117/*--------------------------------------------------------------------------------------------- 118 description: This function decodes all non-priority codewords (non-PCWs) by using a 119 state-machine. 120-------------------------------------------------------------------------------------------- */ 121void DecodeNonPCWs(HANDLE_FDK_BITSTREAM bs, H_HCR_INFO pHcr) 122{ 123 UINT numValidSegment; 124 INT segmentOffset; 125 INT codewordOffsetBase; 126 INT codewordOffset; 127 UINT trial; 128 129 UINT *pNumSegment; 130 SCHAR *pRemainingBitsInSegment; 131 UINT *pSegmentBitfield; 132 UCHAR *pNumWordForBitfield; 133 USHORT *pNumBitValidInLastWord; 134 UINT *pCodewordBitfield; 135 INT bitfieldWord; 136 INT bitInWord; 137 UINT tempWord; 138 UINT interMediateWord; 139 INT tempBit; 140 INT carry; 141 142 UINT numCodeword; 143 UCHAR numSet; 144 UCHAR currentSet; 145 UINT codewordInSet; 146 UINT remainingCodewordsInSet; 147 SCHAR *pSta; 148 UINT ret; 149 150 pNumSegment = &(pHcr->segmentInfo.numSegment); 151 pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment; 152 pSegmentBitfield = pHcr->segmentInfo.pSegmentBitfield; 153 pNumWordForBitfield = &(pHcr->segmentInfo.numWordForBitfield); 154 pNumBitValidInLastWord = &(pHcr->segmentInfo.pNumBitValidInLastWord); 155 pSta = pHcr->nonPcwSideinfo.pSta; 156 157 numValidSegment = InitSegmentBitfield(pNumSegment, 158 pRemainingBitsInSegment, 159 pSegmentBitfield, 160 pNumWordForBitfield, 161 pNumBitValidInLastWord); 162 163 if ( numValidSegment != 0 ) { 164 numCodeword = pHcr->sectionInfo.numCodeword; 165 numSet = ((numCodeword - 1) / *pNumSegment) + 1; 166 167 168 pHcr->segmentInfo.readDirection = FROM_RIGHT_TO_LEFT; 169 170 /* Process sets subsequently */ 171 for ( currentSet = 1; currentSet < numSet ; currentSet++ ) { 172 173 174 175 /* step 1 */ 176 numCodeword -= *pNumSegment; /* number of remaining non PCWs [for all sets] */ 177 if ( numCodeword < *pNumSegment ) { 178 codewordInSet = numCodeword; /* for last set */ 179 } 180 else { 181 codewordInSet = *pNumSegment; /* for all sets except last set */ 182 } 183 184 /* step 2 */ 185 /* prepare array 'CodewordBitfield'; as much ones are written from left in all words, as much decodedCodewordInSetCounter nonPCWs exist in this set */ 186 tempWord = 0xFFFFFFFF; 187 pCodewordBitfield = pHcr->segmentInfo.pCodewordBitfield; 188 189 for ( bitfieldWord = *pNumWordForBitfield; bitfieldWord !=0; bitfieldWord-- ) { /* loop over all used words */ 190 if ( codewordInSet > NUMBER_OF_BIT_IN_WORD ) { /* more codewords than number of bits => fill ones */ 191 /* fill a whole word with ones */ 192 *pCodewordBitfield++ = tempWord; 193 codewordInSet -= NUMBER_OF_BIT_IN_WORD; /* subtract number of bits */ 194 } 195 else { 196 /* prepare last tempWord */ 197 for (remainingCodewordsInSet = codewordInSet; remainingCodewordsInSet < NUMBER_OF_BIT_IN_WORD ; remainingCodewordsInSet++ ) { 198 tempWord = tempWord & ~(1 << (NUMBER_OF_BIT_IN_WORD-1-remainingCodewordsInSet)); /* set a zero at bit number (NUMBER_OF_BIT_IN_WORD-1-i) in tempWord */ 199 } 200 *pCodewordBitfield++ = tempWord; 201 tempWord = 0x00000000; 202 } 203 } 204 pCodewordBitfield = pHcr->segmentInfo.pCodewordBitfield; 205 206 /* step 3 */ 207 /* build non-PCW sideinfo for each non-PCW of the current set */ 208 InitNonPCWSideInformationForCurrentSet(pHcr); 209 210 /* step 4 */ 211 /* decode all non-PCWs belonging to this set */ 212 213 /* loop over trials */ 214 codewordOffsetBase = 0; 215 for ( trial = *pNumSegment; trial > 0; trial-- ) { 216 217 /* loop over number of words in bitfields */ 218 segmentOffset = 0; /* start at zero in every segment */ 219 pHcr->segmentInfo.segmentOffset = segmentOffset; /* store in structure for states */ 220 codewordOffset = codewordOffsetBase; 221 pHcr->nonPcwSideinfo.codewordOffset = codewordOffset; /* store in structure for states */ 222 223 for ( bitfieldWord=0; bitfieldWord < *pNumWordForBitfield; bitfieldWord++ ) { 224 225 /* derive tempWord with bitwise and */ 226 tempWord = pSegmentBitfield[bitfieldWord] & pCodewordBitfield[bitfieldWord]; 227 228 /* if tempWord is not zero, decode something */ 229 if ( tempWord != 0 ) { 230 231 232 /* loop over all bits in tempWord; start state machine if & is true */ 233 for ( bitInWord = NUMBER_OF_BIT_IN_WORD; bitInWord > 0; bitInWord-- ) { 234 235 interMediateWord = ((UINT)1 << (bitInWord-1) ); 236 if ( ( tempWord & interMediateWord ) == interMediateWord ) { 237 238 /* get state and start state machine */ 239 pHcr->nonPcwSideinfo.pState = aStateConstant2State[pSta[codewordOffset]]; 240 241 while(pHcr->nonPcwSideinfo.pState) { 242 ret = ((STATEFUNC) pHcr->nonPcwSideinfo.pState)(bs, pHcr); 243#if STATE_MACHINE_ERROR_CHECK 244 if ( ret != 0 ) { 245 return; 246 } 247#endif 248 } 249 } 250 251 /* update both offsets */ 252 segmentOffset += 1; /* add NUMBER_OF_BIT_IN_WORD times one */ 253 pHcr->segmentInfo.segmentOffset = segmentOffset; 254 codewordOffset += 1; /* add NUMBER_OF_BIT_IN_WORD times one */ 255 codewordOffset = ModuloValue(codewordOffset,*pNumSegment); /* index of the current codeword lies within modulo range */ 256 pHcr->nonPcwSideinfo.codewordOffset = codewordOffset; 257 } 258 } 259 else { 260 segmentOffset += NUMBER_OF_BIT_IN_WORD; /* add NUMBER_OF_BIT_IN_WORD at once */ 261 pHcr->segmentInfo.segmentOffset = segmentOffset; 262 codewordOffset += NUMBER_OF_BIT_IN_WORD; /* add NUMBER_OF_BIT_IN_WORD at once */ 263 codewordOffset = ModuloValue(codewordOffset,*pNumSegment); /* index of the current codeword lies within modulo range */ 264 pHcr->nonPcwSideinfo.codewordOffset = codewordOffset; 265 } 266 } /* end of bitfield word loop */ 267 268 /* decrement codeword - pointer */ 269 codewordOffsetBase -= 1; 270 codewordOffsetBase = ModuloValue(codewordOffsetBase,*pNumSegment); /* index of the current codeword base lies within modulo range */ 271 272 /* rotate numSegment bits in codewordBitfield */ 273 /* rotation of *numSegment bits in bitfield of codewords (circle-rotation) */ 274 /* get last valid bit */ 275 tempBit = pCodewordBitfield[*pNumWordForBitfield-1] & (1 << (NUMBER_OF_BIT_IN_WORD - *pNumBitValidInLastWord)); 276 tempBit = tempBit >> (NUMBER_OF_BIT_IN_WORD - *pNumBitValidInLastWord); 277 278 /* write zero into place where tempBit was fetched from */ 279 pCodewordBitfield[*pNumWordForBitfield-1] = pCodewordBitfield[*pNumWordForBitfield-1] & ~(1 << (NUMBER_OF_BIT_IN_WORD - *pNumBitValidInLastWord)); 280 281 /* rotate last valid word */ 282 pCodewordBitfield[*pNumWordForBitfield-1] = pCodewordBitfield[*pNumWordForBitfield-1] >> 1; 283 284 /* transfare carry bit 0 from current word into bitposition 31 from next word and rotate current word */ 285 for ( bitfieldWord = *pNumWordForBitfield-2; bitfieldWord > -1 ; bitfieldWord-- ) { 286 /* get carry (=bit at position 0) from current word */ 287 carry = pCodewordBitfield[bitfieldWord] & 1; 288 289 /* put the carry bit at position 31 into word right from current word */ 290 pCodewordBitfield[bitfieldWord+1] = pCodewordBitfield[bitfieldWord+1] | (carry << (NUMBER_OF_BIT_IN_WORD-1)); 291 292 /* shift current word */ 293 pCodewordBitfield[bitfieldWord] = pCodewordBitfield[bitfieldWord] >> 1; 294 } 295 296 /* put tempBit into free bit-position 31 from first word */ 297 pCodewordBitfield[0] = pCodewordBitfield[0] | (tempBit << (NUMBER_OF_BIT_IN_WORD-1)); 298 299 } /* end of trial loop */ 300 301 /* toggle read direction */ 302 pHcr->segmentInfo.readDirection = ToggleReadDirection(pHcr->segmentInfo.readDirection); 303 304 } 305 /* end of set loop */ 306 307 /* all non-PCWs of this spectrum are decoded */ 308 } 309 310 /* all PCWs and all non PCWs are decoded. They are unbacksorted in output buffer. Here is the Interface with comparing QSCs to asm decoding */ 311} 312 313 314/*--------------------------------------------------------------------------------------------- 315 description: This function prepares the bitfield used for the 316 segments. The list is set up once to be used in all following sets. If a 317 segment is decoded empty, the according bit from the Bitfield is removed. 318----------------------------------------------------------------------------------------------- 319 return: numValidSegment = the number of valid segments 320-------------------------------------------------------------------------------------------- */ 321static UINT InitSegmentBitfield(UINT *pNumSegment, 322 SCHAR *pRemainingBitsInSegment, 323 UINT *pSegmentBitfield, 324 UCHAR *pNumWordForBitfield, 325 USHORT *pNumBitValidInLastWord) 326{ 327 SHORT i; 328 USHORT r; 329 UCHAR bitfieldWord; 330 UINT tempWord; 331 USHORT numValidSegment; 332 333 *pNumWordForBitfield = ((*pNumSegment-1) >> THIRTYTWO_LOG_DIV_TWO_LOG) + 1; 334 335 /* loop over all words, which are completely used or only partial */ 336 /* bit in pSegmentBitfield is zero if segment is empty; bit in pSegmentBitfield is one if segment is not empty */ 337 numValidSegment = 0; 338 *pNumBitValidInLastWord = *pNumSegment; 339 340 /* loop over words */ 341 for ( bitfieldWord=0; bitfieldWord < *pNumWordForBitfield - 1; bitfieldWord++ ) { 342 tempWord = 0xFFFFFFFF; /* set ones */ 343 r = bitfieldWord << THIRTYTWO_LOG_DIV_TWO_LOG; 344 for ( i=0; i < NUMBER_OF_BIT_IN_WORD; i++) { 345 if ( pRemainingBitsInSegment[r + i] == 0 ) { 346 tempWord = tempWord & ~(1 << (NUMBER_OF_BIT_IN_WORD-1-i)); /* set a zero at bit number (NUMBER_OF_BIT_IN_WORD-1-i) in tempWord */ 347 } 348 else { 349 numValidSegment += 1; /* count segments which are not empty */ 350 } 351 } 352 pSegmentBitfield[bitfieldWord] = tempWord; /* store result */ 353 *pNumBitValidInLastWord -= NUMBER_OF_BIT_IN_WORD; /* calculate number of zeros on LSB side in the last word */ 354 } 355 356 357 /* calculate last word: prepare special tempWord */ 358 tempWord = 0xFFFFFFFF; 359 for ( i=0; i < ( NUMBER_OF_BIT_IN_WORD - *pNumBitValidInLastWord ); i++ ) { 360 tempWord = tempWord & ~(1 << i); /* clear bit i in tempWord */ 361 } 362 363 /* calculate last word */ 364 r = bitfieldWord << THIRTYTWO_LOG_DIV_TWO_LOG; 365 for ( i=0; i<*pNumBitValidInLastWord; i++) { 366 if ( pRemainingBitsInSegment[r + i] == 0 ) { 367 tempWord = tempWord & ~(1 << (NUMBER_OF_BIT_IN_WORD-1-i)); /* set a zero at bit number (NUMBER_OF_BIT_IN_WORD-1-i) in tempWord */ 368 } 369 else { 370 numValidSegment += 1; /* count segments which are not empty */ 371 } 372 } 373 pSegmentBitfield[bitfieldWord] = tempWord; /* store result */ 374 375 376 377 return numValidSegment; 378} 379 380 381/*--------------------------------------------------------------------------------------------- 382 description: This function sets up sideinfo for the non-PCW decoder (for the current set). 383---------------------------------------------------------------------------------------------*/ 384static void InitNonPCWSideInformationForCurrentSet(H_HCR_INFO pHcr) 385{ 386 USHORT i,k; 387 UCHAR codebookDim; 388 UINT startNode; 389 390 UCHAR *pCodebook = pHcr->nonPcwSideinfo.pCodebook; 391 UINT *iNode = pHcr->nonPcwSideinfo.iNode; 392 UCHAR *pCntSign = pHcr->nonPcwSideinfo.pCntSign; 393 USHORT *iResultPointer = pHcr->nonPcwSideinfo.iResultPointer; 394 UINT *pEscapeSequenceInfo = pHcr->nonPcwSideinfo.pEscapeSequenceInfo; 395 SCHAR *pSta = pHcr->nonPcwSideinfo.pSta; 396 USHORT *pNumExtendedSortedCodewordInSection = pHcr->sectionInfo.pNumExtendedSortedCodewordInSection; 397 int numExtendedSortedCodewordInSectionIdx = pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx; 398 UCHAR *pExtendedSortedCodebook = pHcr->sectionInfo.pExtendedSortedCodebook; 399 int extendedSortedCodebookIdx = pHcr->sectionInfo.extendedSortedCodebookIdx; 400 USHORT *pNumExtendedSortedSectionsInSets = pHcr->sectionInfo.pNumExtendedSortedSectionsInSets; 401 int numExtendedSortedSectionsInSetsIdx = pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx; 402 FIXP_DBL *pQuantizedSpectralCoefficients = SPEC_LONG(pHcr->decInOut.pQuantizedSpectralCoefficientsBase); 403 int quantizedSpectralCoefficientsIdx = pHcr->decInOut.quantizedSpectralCoefficientsIdx; 404 const UCHAR *pCbDimension = pHcr->tableInfo.pCbDimension; 405 int iterationCounter = 0; 406 407 /* loop over number of extended sorted sections in the current set so all codewords sideinfo variables within this set can be prepared for decoding */ 408 for ( i=pNumExtendedSortedSectionsInSets[numExtendedSortedSectionsInSetsIdx]; i != 0; i-- ) { 409 410 codebookDim = pCbDimension[pExtendedSortedCodebook[extendedSortedCodebookIdx]]; 411 startNode = *aHuffTable[pExtendedSortedCodebook[extendedSortedCodebookIdx]]; 412 413 for ( k = pNumExtendedSortedCodewordInSection[numExtendedSortedCodewordInSectionIdx]; k != 0; k-- ) { 414 iterationCounter++; 415 if (iterationCounter > (1024>>2)) { 416 return; 417 } 418 *pSta++ = aCodebook2StartInt[pExtendedSortedCodebook[extendedSortedCodebookIdx]]; 419 *pCodebook++ = pExtendedSortedCodebook[extendedSortedCodebookIdx]; 420 *iNode++ = startNode; 421 *pCntSign++ = 0; 422 *iResultPointer++ = quantizedSpectralCoefficientsIdx; 423 *pEscapeSequenceInfo++ = 0; 424 quantizedSpectralCoefficientsIdx += codebookDim; /* update pointer by codebookDim --> point to next starting value for writing out */ 425 if (quantizedSpectralCoefficientsIdx >= 1024) { 426 return; 427 } 428 } 429 numExtendedSortedCodewordInSectionIdx++; /* inc ptr for next ext sort sec in current set */ 430 extendedSortedCodebookIdx++; /* inc ptr for next ext sort sec in current set */ 431 if (numExtendedSortedCodewordInSectionIdx >= (MAX_SFB_HCR+MAX_HCR_SETS) || extendedSortedCodebookIdx >= (MAX_SFB_HCR+MAX_HCR_SETS)) { 432 return; 433 } 434 } 435 numExtendedSortedSectionsInSetsIdx++; /* inc ptr for next set of non-PCWs */ 436 if (numExtendedSortedCodewordInSectionIdx >= (MAX_SFB_HCR+MAX_HCR_SETS)) { 437 return; 438 } 439 440 /* Write back indexes */ 441 pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx = numExtendedSortedCodewordInSectionIdx; 442 pHcr->sectionInfo.extendedSortedCodebookIdx = extendedSortedCodebookIdx; 443 pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx = numExtendedSortedSectionsInSetsIdx; 444 pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx = numExtendedSortedCodewordInSectionIdx; 445 pHcr->decInOut.quantizedSpectralCoefficientsIdx = quantizedSpectralCoefficientsIdx; 446} 447 448 449/*--------------------------------------------------------------------------------------------- 450 description: This function returns the input value if the value is in the 451 range of bufferlength. If <input> is smaller, one bufferlength is added, 452 if <input> is bigger one bufferlength is subtracted. 453----------------------------------------------------------------------------------------------- 454 return: modulo result 455-------------------------------------------------------------------------------------------- */ 456static INT ModuloValue(INT input, INT bufferlength) 457{ 458 if ( input > (bufferlength - 1) ) { 459 return (input - bufferlength); 460 } 461 if ( input < 0 ) { 462 return (input + bufferlength); 463 } 464 return input; 465} 466 467 468/*--------------------------------------------------------------------------------------------- 469 description: This function clears a bit from current bitfield and 470 switches off the statemachine. 471 472 A bit is cleared in two cases: 473 a) a codeword is decoded, then a bit is cleared in codeword bitfield 474 b) a segment is decoded empty, then a bit is cleared in segment bitfield 475-------------------------------------------------------------------------------------------- */ 476static void ClearBitFromBitfield(STATEFUNC *ptrState, 477 UINT offset, 478 UINT *pBitfield) 479{ 480 UINT numBitfieldWord; 481 UINT numBitfieldBit; 482 483 /* get both values needed for clearing the bit */ 484 numBitfieldWord = offset >> THIRTYTWO_LOG_DIV_TWO_LOG; /* int = wordNr */ 485 numBitfieldBit = offset - (numBitfieldWord << THIRTYTWO_LOG_DIV_TWO_LOG); /* fract = bitNr */ 486 487 /* clear a bit in bitfield */ 488 pBitfield[numBitfieldWord] = pBitfield[numBitfieldWord] & ~(1 << (NUMBER_OF_BIT_IN_WORD-1 - numBitfieldBit)); 489 490 /* switch off state machine because codeword is decoded and/or because segment is empty */ 491 *ptrState = NULL; 492} 493 494 495 496/* ========================================================================================= 497 the states of the statemachine 498 ========================================================================================= */ 499 500 501/*--------------------------------------------------------------------------------------------- 502 description: Decodes the body of a codeword. This State is used for codebooks 1,2,5 and 6. 503 No sign bits are decoded, because the table of the quantized spectral values 504 has got a valid sign at the quantized spectral lines. 505----------------------------------------------------------------------------------------------- 506 output: Two or four quantizes spectral values written at position where pResultPointr 507 points to 508----------------------------------------------------------------------------------------------- 509 return: 0 510-------------------------------------------------------------------------------------------- */ 511UINT Hcr_State_BODY_ONLY(HANDLE_FDK_BITSTREAM bs, void *ptr) 512{ 513 H_HCR_INFO pHcr = (H_HCR_INFO)ptr; 514 UINT *pSegmentBitfield; 515 UINT *pCodewordBitfield; 516 UINT segmentOffset; 517 FIXP_DBL *pResultBase; 518 UINT *iNode; 519 USHORT *iResultPointer; 520 UINT codewordOffset; 521 UINT branchNode; 522 UINT branchValue; 523 UINT iQSC; 524 UINT treeNode; 525 UCHAR carryBit; 526 USHORT *pLeftStartOfSegment; 527 USHORT *pRightStartOfSegment; 528 SCHAR *pRemainingBitsInSegment; 529 UCHAR readDirection; 530 UCHAR *pCodebook; 531 UCHAR dimCntr; 532 const UINT *pCurrentTree; 533 const UCHAR *pCbDimension; 534 const SCHAR *pQuantVal; 535 const SCHAR *pQuantValBase; 536 537 pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment; 538 pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment; 539 pRightStartOfSegment = pHcr->segmentInfo.pRightStartOfSegment; 540 readDirection = pHcr->segmentInfo.readDirection; 541 pSegmentBitfield = pHcr->segmentInfo.pSegmentBitfield; 542 pCodewordBitfield = pHcr->segmentInfo.pCodewordBitfield; 543 segmentOffset = pHcr->segmentInfo.segmentOffset; 544 545 pCodebook = pHcr->nonPcwSideinfo.pCodebook; 546 iNode = pHcr->nonPcwSideinfo.iNode; 547 pResultBase = pHcr->nonPcwSideinfo.pResultBase; 548 iResultPointer = pHcr->nonPcwSideinfo.iResultPointer; 549 codewordOffset = pHcr->nonPcwSideinfo.codewordOffset; 550 551 pCbDimension = pHcr->tableInfo.pCbDimension; 552 553 treeNode = iNode[codewordOffset]; 554 pCurrentTree = aHuffTable[pCodebook[codewordOffset]]; 555 556 557 for ( ; pRemainingBitsInSegment[segmentOffset] > 0 ; pRemainingBitsInSegment[segmentOffset] -= 1 ) { 558 559 carryBit = HcrGetABitFromBitstream( bs, 560 &pLeftStartOfSegment[segmentOffset], 561 &pRightStartOfSegment[segmentOffset], 562 readDirection); 563 564 CarryBitToBranchValue(carryBit, /* make a step in decoding tree */ 565 treeNode, 566 &branchValue, 567 &branchNode); 568 569 /* if end of branch reached write out lines and count bits needed for sign, otherwise store node in codeword sideinfo */ 570 if ((branchNode & TEST_BIT_10) == TEST_BIT_10) { /* test bit 10 ; ==> body is complete */ 571 pQuantValBase = aQuantTable[pCodebook[codewordOffset]]; /* get base address of quantized values belonging to current codebook */ 572 pQuantVal = pQuantValBase + branchValue; /* set pointer to first valid line [of 2 or 4 quantized values] */ 573 574 iQSC = iResultPointer[codewordOffset]; /* get position of first line for writing out result */ 575 576 for ( dimCntr = pCbDimension[pCodebook[codewordOffset]]; dimCntr != 0; dimCntr-- ) { 577 pResultBase[iQSC++] = (FIXP_DBL)*pQuantVal++; /* write out 2 or 4 lines into spectrum; no Sign bits available in this state */ 578 } 579 580 ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState), 581 segmentOffset, 582 pCodewordBitfield); /* clear a bit in bitfield and switch off statemachine */ 583 pRemainingBitsInSegment[segmentOffset] -= 1; /* last reinitialzation of for loop counter (see above) is done here */ 584 break; /* end of branch in tree reached i.e. a whole nonPCW-Body is decoded */ 585 } 586 else { /* body is not decoded completely: */ 587 treeNode = *(pCurrentTree + branchValue); /* update treeNode for further step in decoding tree */ 588 } 589 } 590 iNode[codewordOffset] = treeNode; /* store updated treeNode because maybe decoding of codeword body not finished yet */ 591 592 if ( pRemainingBitsInSegment[segmentOffset] <= 0 ) { 593 ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState), 594 segmentOffset, 595 pSegmentBitfield); /* clear a bit in bitfield and switch off statemachine */ 596 597#if STATE_MACHINE_ERROR_CHECK 598 if ( pRemainingBitsInSegment[segmentOffset] < 0 ) { 599 pHcr->decInOut.errorLog |= STATE_ERROR_BODY_ONLY; 600 return BODY_ONLY; 601 } 602#endif 603 } 604 605 return STOP_THIS_STATE; 606} 607 608 609/*--------------------------------------------------------------------------------------------- 610 description: Decodes the codeword body, writes out result and counts the number of quantized 611 spectral values, which are different form zero. For those values sign bits are 612 needed. 613 614 If sign bit counter cntSign is different from zero, switch to next state to 615 decode sign Bits there. 616 If sign bit counter cntSign is zero, no sign bits are needed and codeword is 617 decoded. 618----------------------------------------------------------------------------------------------- 619 output: Two or four written quantizes spectral values written at position where 620 pResultPointr points to. The signs of those lines may be wrong. If the signs 621 [on just one signle sign] is wrong, the next state will correct it. 622----------------------------------------------------------------------------------------------- 623 return: 0 624-------------------------------------------------------------------------------------------- */ 625UINT Hcr_State_BODY_SIGN__BODY(HANDLE_FDK_BITSTREAM bs, void *ptr) 626{ 627 H_HCR_INFO pHcr = (H_HCR_INFO)ptr; 628 SCHAR *pRemainingBitsInSegment; 629 USHORT *pLeftStartOfSegment; 630 USHORT *pRightStartOfSegment; 631 UCHAR readDirection; 632 UINT *pSegmentBitfield; 633 UINT *pCodewordBitfield; 634 UINT segmentOffset; 635 636 UCHAR *pCodebook; 637 UINT *iNode; 638 UCHAR *pCntSign; 639 FIXP_DBL *pResultBase; 640 USHORT *iResultPointer; 641 UINT codewordOffset; 642 643 UINT iQSC; 644 UINT cntSign; 645 UCHAR dimCntr; 646 UCHAR carryBit; 647 SCHAR *pSta; 648 UINT treeNode; 649 UINT branchValue; 650 UINT branchNode; 651 const UCHAR *pCbDimension; 652 const UINT *pCurrentTree; 653 const SCHAR *pQuantValBase; 654 const SCHAR *pQuantVal; 655 656 pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment; 657 pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment; 658 pRightStartOfSegment = pHcr->segmentInfo.pRightStartOfSegment; 659 readDirection = pHcr->segmentInfo.readDirection; 660 pSegmentBitfield = pHcr->segmentInfo.pSegmentBitfield; 661 pCodewordBitfield = pHcr->segmentInfo.pCodewordBitfield; 662 segmentOffset = pHcr->segmentInfo.segmentOffset; 663 664 pCodebook = pHcr->nonPcwSideinfo.pCodebook; 665 iNode = pHcr->nonPcwSideinfo.iNode; 666 pCntSign = pHcr->nonPcwSideinfo.pCntSign; 667 pResultBase = pHcr->nonPcwSideinfo.pResultBase; 668 iResultPointer = pHcr->nonPcwSideinfo.iResultPointer; 669 codewordOffset = pHcr->nonPcwSideinfo.codewordOffset; 670 pSta = pHcr->nonPcwSideinfo.pSta; 671 672 pCbDimension = pHcr->tableInfo.pCbDimension; 673 674 treeNode = iNode[codewordOffset]; 675 pCurrentTree = aHuffTable[pCodebook[codewordOffset]]; 676 677 678 for ( ; pRemainingBitsInSegment[segmentOffset] > 0 ; pRemainingBitsInSegment[segmentOffset] -= 1 ) { 679 680 carryBit = HcrGetABitFromBitstream( bs, 681 &pLeftStartOfSegment[segmentOffset], 682 &pRightStartOfSegment[segmentOffset], 683 readDirection); 684 685 CarryBitToBranchValue(carryBit, /* make a step in decoding tree */ 686 treeNode, 687 &branchValue, 688 &branchNode); 689 690 /* if end of branch reached write out lines and count bits needed for sign, otherwise store node in codeword sideinfo */ 691 if ((branchNode & TEST_BIT_10) == TEST_BIT_10) { /* test bit 10 ; if set body complete */ 692 /* body completely decoded; branchValue is valid, set pQuantVal to first (of two or four) quantized spectral coefficients */ 693 pQuantValBase = aQuantTable[pCodebook[codewordOffset]]; /* get base address of quantized values belonging to current codebook */ 694 pQuantVal = pQuantValBase + branchValue; /* set pointer to first valid line [of 2 or 4 quantized values] */ 695 696 iQSC = iResultPointer[codewordOffset]; /* get position of first line for writing result */ 697 698 /* codeword decoding result is written out here: Write out 2 or 4 quantized spectral values with probably */ 699 /* wrong sign and count number of values which are different from zero for sign bit decoding [which happens in next state] */ 700 cntSign = 0; 701 for ( dimCntr = pCbDimension[pCodebook[codewordOffset]]; dimCntr != 0; dimCntr-- ) { 702 pResultBase[iQSC++] = (FIXP_DBL)*pQuantVal; /* write quant. spec. coef. into spectrum */ 703 if ( *pQuantVal++ != 0 ) { 704 cntSign += 1; 705 } 706 } 707 708 if ( cntSign == 0 ) { 709 ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState), 710 segmentOffset, 711 pCodewordBitfield); /* clear a bit in bitfield and switch off statemachine */ 712 } 713 else { 714 pCntSign[codewordOffset] = cntSign; /* write sign count result into codewordsideinfo of current codeword */ 715 pSta[codewordOffset] = BODY_SIGN__SIGN; /* change state */ 716 pHcr->nonPcwSideinfo.pState = aStateConstant2State[pSta[codewordOffset]]; /* get state from separate array of cw-sideinfo */ 717 } 718 pRemainingBitsInSegment[segmentOffset] -= 1; /* last reinitialzation of for loop counter (see above) is done here */ 719 break; /* end of branch in tree reached i.e. a whole nonPCW-Body is decoded */ 720 } 721 else {/* body is not decoded completely: */ 722 treeNode = *(pCurrentTree + branchValue); /* update treeNode for further step in decoding tree */ 723 } 724 } 725 iNode[codewordOffset] = treeNode; /* store updated treeNode because maybe decoding of codeword body not finished yet */ 726 727 if ( pRemainingBitsInSegment[segmentOffset] <= 0 ) { 728 ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState), 729 segmentOffset, 730 pSegmentBitfield); /* clear a bit in bitfield and switch off statemachine */ 731 732#if STATE_MACHINE_ERROR_CHECK 733 if ( pRemainingBitsInSegment[segmentOffset] < 0 ) { 734 pHcr->decInOut.errorLog |= STATE_ERROR_BODY_SIGN__BODY; 735 return BODY_SIGN__BODY; 736 } 737#endif 738 } 739 740 return STOP_THIS_STATE; 741} 742 743 744/*--------------------------------------------------------------------------------------------- 745 description: This state decodes the sign bits belonging to a codeword. The state is called 746 as often in different "trials" until pCntSgn[codewordOffset] is zero. 747----------------------------------------------------------------------------------------------- 748 output: The two or four quantizes spectral values (written in previous state) have 749 now the correct sign. 750----------------------------------------------------------------------------------------------- 751 return: 0 752-------------------------------------------------------------------------------------------- */ 753UINT Hcr_State_BODY_SIGN__SIGN(HANDLE_FDK_BITSTREAM bs, void *ptr) 754{ 755 H_HCR_INFO pHcr = (H_HCR_INFO)ptr; 756 SCHAR *pRemainingBitsInSegment; 757 USHORT *pLeftStartOfSegment; 758 USHORT *pRightStartOfSegment; 759 UCHAR readDirection; 760 UINT *pSegmentBitfield; 761 UINT *pCodewordBitfield; 762 UINT segmentOffset; 763 764 UCHAR *pCntSign; 765 FIXP_DBL *pResultBase; 766 USHORT *iResultPointer; 767 UINT codewordOffset; 768 UCHAR carryBit; 769 UINT iQSC; 770 UCHAR cntSign; 771 772 pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment; 773 pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment; 774 pRightStartOfSegment = pHcr->segmentInfo.pRightStartOfSegment; 775 readDirection = pHcr->segmentInfo.readDirection; 776 pSegmentBitfield = pHcr->segmentInfo.pSegmentBitfield; 777 pCodewordBitfield = pHcr->segmentInfo.pCodewordBitfield; 778 segmentOffset = pHcr->segmentInfo.segmentOffset; 779 780 pCntSign = pHcr->nonPcwSideinfo.pCntSign; 781 pResultBase = pHcr->nonPcwSideinfo.pResultBase; 782 iResultPointer = pHcr->nonPcwSideinfo.iResultPointer; 783 codewordOffset = pHcr->nonPcwSideinfo.codewordOffset; 784 iQSC = iResultPointer[codewordOffset]; 785 cntSign = pCntSign[codewordOffset]; 786 787 788 789 /* loop for sign bit decoding */ 790 for ( ; pRemainingBitsInSegment[segmentOffset] > 0 ; pRemainingBitsInSegment[segmentOffset] -= 1 ) { 791 792 carryBit = HcrGetABitFromBitstream( bs, 793 &pLeftStartOfSegment[segmentOffset], 794 &pRightStartOfSegment[segmentOffset], 795 readDirection); 796 cntSign -= 1; /* decrement sign counter because one sign bit has been read */ 797 798 /* search for a line (which was decoded in previous state) which is not zero. [This value will get a sign] */ 799 while ( pResultBase[iQSC] == (FIXP_DBL)0 ) { 800 iQSC++; /* points to current value different from zero */ 801 if (iQSC >= 1024) { 802 return BODY_SIGN__SIGN; 803 } 804 } 805 806 /* put sign together with line; if carryBit is zero, the sign is ok already; no write operation necessary in this case */ 807 if ( carryBit != 0 ) { 808 pResultBase[iQSC] = -pResultBase[iQSC]; /* carryBit = 1 --> minus */ 809 } 810 811 iQSC++; /* update pointer to next (maybe valid) value */ 812 813 if ( cntSign == 0 ) { /* if (cntSign==0) ==> set state CODEWORD_DECODED */ 814 ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState), 815 segmentOffset, 816 pCodewordBitfield); /* clear a bit in bitfield and switch off statemachine */ 817 pRemainingBitsInSegment[segmentOffset] -= 1; /* last reinitialzation of for loop counter (see above) is done here */ 818 break; /* whole nonPCW-Body and according sign bits are decoded */ 819 } 820 } 821 pCntSign[codewordOffset] = cntSign; 822 iResultPointer[codewordOffset] = iQSC; /* store updated pResultPointer */ 823 824 if ( pRemainingBitsInSegment[segmentOffset] <= 0 ) { 825 ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState), 826 segmentOffset, 827 pSegmentBitfield); /* clear a bit in bitfield and switch off statemachine */ 828 829#if STATE_MACHINE_ERROR_CHECK 830 if ( pRemainingBitsInSegment[segmentOffset] < 0 ) { 831 pHcr->decInOut.errorLog |= STATE_ERROR_BODY_SIGN__SIGN; 832 return BODY_SIGN__SIGN; 833 } 834#endif 835 } 836 837 return STOP_THIS_STATE; 838} 839 840 841/*--------------------------------------------------------------------------------------------- 842 description: Decodes the codeword body in case of codebook is 11. Writes out resulting 843 two or four lines [with probably wrong sign] and counts the number of 844 lines, which are different form zero. This information is needed in next 845 state where sign bits will be decoded, if necessary. 846 If sign bit counter cntSign is zero, no sign bits are needed and codeword is 847 decoded completely. 848----------------------------------------------------------------------------------------------- 849 output: Two lines (quantizes spectral coefficients) which are probably wrong. The 850 sign may be wrong and if one or two values is/are 16, the following states 851 will decode the escape sequence to correct the values which are wirtten here. 852----------------------------------------------------------------------------------------------- 853 return: 0 854-------------------------------------------------------------------------------------------- */ 855UINT Hcr_State_BODY_SIGN_ESC__BODY(HANDLE_FDK_BITSTREAM bs, void *ptr) 856{ 857 H_HCR_INFO pHcr = (H_HCR_INFO)ptr; 858 SCHAR *pRemainingBitsInSegment; 859 USHORT *pLeftStartOfSegment; 860 USHORT *pRightStartOfSegment; 861 UCHAR readDirection; 862 UINT *pSegmentBitfield; 863 UINT *pCodewordBitfield; 864 UINT segmentOffset; 865 866 UINT *iNode; 867 UCHAR *pCntSign; 868 FIXP_DBL *pResultBase; 869 USHORT *iResultPointer; 870 UINT codewordOffset; 871 872 UCHAR carryBit; 873 UINT iQSC; 874 UINT cntSign; 875 UINT dimCntr; 876 UINT treeNode; 877 SCHAR *pSta; 878 UINT branchNode; 879 UINT branchValue; 880 const UINT *pCurrentTree; 881 const SCHAR *pQuantValBase; 882 const SCHAR *pQuantVal; 883 884 pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment; 885 pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment; 886 pRightStartOfSegment = pHcr->segmentInfo.pRightStartOfSegment; 887 readDirection = pHcr->segmentInfo.readDirection; 888 pSegmentBitfield = pHcr->segmentInfo.pSegmentBitfield; 889 pCodewordBitfield = pHcr->segmentInfo.pCodewordBitfield; 890 segmentOffset = pHcr->segmentInfo.segmentOffset; 891 892 iNode = pHcr->nonPcwSideinfo.iNode; 893 pCntSign = pHcr->nonPcwSideinfo.pCntSign; 894 pResultBase = pHcr->nonPcwSideinfo.pResultBase; 895 iResultPointer = pHcr->nonPcwSideinfo.iResultPointer; 896 codewordOffset = pHcr->nonPcwSideinfo.codewordOffset; 897 pSta = pHcr->nonPcwSideinfo.pSta; 898 899 treeNode = iNode[codewordOffset]; 900 pCurrentTree = aHuffTable[ESCAPE_CODEBOOK]; 901 902 903 for ( ; pRemainingBitsInSegment[segmentOffset] > 0 ; pRemainingBitsInSegment[segmentOffset] -= 1 ) { 904 905 carryBit = HcrGetABitFromBitstream( bs, 906 &pLeftStartOfSegment[segmentOffset], 907 &pRightStartOfSegment[segmentOffset], 908 readDirection); 909 910 /* make a step in tree */ 911 CarryBitToBranchValue(carryBit, 912 treeNode, 913 &branchValue, 914 &branchNode); 915 916 /* if end of branch reached write out lines and count bits needed for sign, otherwise store node in codeword sideinfo */ 917 if ((branchNode & TEST_BIT_10) == TEST_BIT_10) { /* test bit 10 ; if set body complete */ 918 919 /* body completely decoded; branchValue is valid */ 920 /* set pQuantVol to first (of two or four) quantized spectral coefficients */ 921 pQuantValBase = aQuantTable[ESCAPE_CODEBOOK]; /* get base address of quantized values belonging to current codebook */ 922 pQuantVal = pQuantValBase + branchValue; /* set pointer to first valid line [of 2 or 4 quantized values] */ 923 924 /* make backup from original resultPointer in node storage for state BODY_SIGN_ESC__SIGN */ 925 iNode[codewordOffset] = iResultPointer[codewordOffset]; 926 927 /* get position of first line for writing result */ 928 iQSC = iResultPointer[codewordOffset]; 929 930 /* codeword decoding result is written out here: Write out 2 or 4 quantized spectral values with probably */ 931 /* wrong sign and count number of values which are different from zero for sign bit decoding [which happens in next state] */ 932 cntSign = 0; 933 934 for ( dimCntr = DIMENSION_OF_ESCAPE_CODEBOOK; dimCntr != 0; dimCntr-- ) { 935 pResultBase[iQSC++] = (FIXP_DBL)*pQuantVal; /* write quant. spec. coef. into spectrum */ 936 if ( *pQuantVal++ != 0 ) { 937 cntSign += 1; 938 } 939 } 940 941 if ( cntSign == 0 ) { 942 ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState), 943 segmentOffset, 944 pCodewordBitfield); /* clear a bit in bitfield and switch off statemachine */ 945 /* codeword decoded */ 946 } 947 else { 948 /* write sign count result into codewordsideinfo of current codeword */ 949 pCntSign[codewordOffset] = cntSign; 950 pSta[codewordOffset] = BODY_SIGN_ESC__SIGN; /* change state */ 951 pHcr->nonPcwSideinfo.pState = aStateConstant2State[pSta[codewordOffset]]; /* get state from separate array of cw-sideinfo */ 952 } 953 pRemainingBitsInSegment[segmentOffset] -= 1; /* the last reinitialzation of for loop counter (see above) is done here */ 954 break; /* end of branch in tree reached i.e. a whole nonPCW-Body is decoded */ 955 } 956 else { /* body is not decoded completely: */ 957 /* update treeNode for further step in decoding tree and store updated treeNode because maybe no more bits left in segment */ 958 treeNode = *(pCurrentTree + branchValue); 959 iNode[codewordOffset] = treeNode; 960 } 961 } 962 963 if ( pRemainingBitsInSegment[segmentOffset] <= 0 ) { 964 ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState), 965 segmentOffset, 966 pSegmentBitfield); /* clear a bit in bitfield and switch off statemachine */ 967 968#if STATE_MACHINE_ERROR_CHECK 969 if ( pRemainingBitsInSegment[segmentOffset] < 0 ) { 970 pHcr->decInOut.errorLog |= STATE_ERROR_BODY_SIGN_ESC__BODY; 971 return BODY_SIGN_ESC__BODY; 972 } 973#endif 974 } 975 976 return STOP_THIS_STATE; 977} 978 979 980/*--------------------------------------------------------------------------------------------- 981 description: This state decodes the sign bits, if a codeword of codebook 11 needs some. 982 A flag named 'flagB' in codeword sideinfo is set, if the second line of 983 quantized spectral values is 16. The 'flagB' is used in case of decoding 984 of a escape sequence is necessary as far as the second line is concerned. 985 986 If only the first line needs an escape sequence, the flagB is cleared. 987 If only the second line needs an escape sequence, the flagB is not used. 988 989 For storing sideinfo in case of escape sequence decoding one single word 990 can be used for both escape sequences because they are decoded not at the 991 same time: 992 993 994 bit 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 995 ===== == == =========== =========== =================================== 996 ^ ^ ^ ^ ^ ^ 997 | | | | | | 998 res. flagA flagB escapePrefixUp escapePrefixDown escapeWord 999 1000----------------------------------------------------------------------------------------------- 1001 output: Two lines with correct sign. If one or two values is/are 16, the lines are 1002 not valid, otherwise they are. 1003----------------------------------------------------------------------------------------------- 1004 return: 0 1005-------------------------------------------------------------------------------------------- */ 1006UINT Hcr_State_BODY_SIGN_ESC__SIGN(HANDLE_FDK_BITSTREAM bs, void *ptr) 1007{ 1008 H_HCR_INFO pHcr = (H_HCR_INFO)ptr; 1009 SCHAR *pRemainingBitsInSegment; 1010 USHORT *pLeftStartOfSegment; 1011 USHORT *pRightStartOfSegment; 1012 UCHAR readDirection; 1013 UINT *pSegmentBitfield; 1014 UINT *pCodewordBitfield; 1015 UINT segmentOffset; 1016 1017 UINT *iNode; 1018 UCHAR *pCntSign; 1019 FIXP_DBL *pResultBase; 1020 USHORT *iResultPointer; 1021 UINT *pEscapeSequenceInfo; 1022 UINT codewordOffset; 1023 1024 UINT iQSC; 1025 UCHAR cntSign; 1026 UINT flagA; 1027 UINT flagB; 1028 UINT flags; 1029 UCHAR carryBit; 1030 SCHAR *pSta; 1031 1032 pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment; 1033 pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment; 1034 pRightStartOfSegment = pHcr->segmentInfo.pRightStartOfSegment; 1035 readDirection = pHcr->segmentInfo.readDirection; 1036 pSegmentBitfield = pHcr->segmentInfo.pSegmentBitfield; 1037 pCodewordBitfield = pHcr->segmentInfo.pCodewordBitfield; 1038 segmentOffset = pHcr->segmentInfo.segmentOffset; 1039 1040 iNode = pHcr->nonPcwSideinfo.iNode; 1041 pCntSign = pHcr->nonPcwSideinfo.pCntSign; 1042 pResultBase = pHcr->nonPcwSideinfo.pResultBase; 1043 iResultPointer = pHcr->nonPcwSideinfo.iResultPointer; 1044 pEscapeSequenceInfo = pHcr->nonPcwSideinfo.pEscapeSequenceInfo; 1045 codewordOffset = pHcr->nonPcwSideinfo.codewordOffset; 1046 pSta = pHcr->nonPcwSideinfo.pSta; 1047 1048 iQSC = iResultPointer[codewordOffset]; 1049 cntSign = pCntSign[codewordOffset]; 1050 1051 1052 /* loop for sign bit decoding */ 1053 for ( ; pRemainingBitsInSegment[segmentOffset] > 0 ; pRemainingBitsInSegment[segmentOffset] -= 1 ) { 1054 1055 carryBit = HcrGetABitFromBitstream( bs, 1056 &pLeftStartOfSegment[segmentOffset], 1057 &pRightStartOfSegment[segmentOffset], 1058 readDirection); 1059 1060 /* decrement sign counter because one sign bit has been read */ 1061 cntSign -= 1; 1062 pCntSign[codewordOffset] = cntSign; 1063 1064 /* get a quantized spectral value (which was decoded in previous state) which is not zero. [This value will get a sign] */ 1065 while ( pResultBase[iQSC] == (FIXP_DBL)0 ) { 1066 iQSC++; 1067 } 1068 iResultPointer[codewordOffset] = iQSC; 1069 1070 /* put negative sign together with quantized spectral value; if carryBit is zero, the sign is ok already; no write operation necessary in this case */ 1071 if ( carryBit != 0 ) { 1072 pResultBase[iQSC] = - pResultBase[iQSC]; /* carryBit = 1 --> minus */ 1073 } 1074 iQSC++; /* update index to next (maybe valid) value */ 1075 iResultPointer[codewordOffset] = iQSC; 1076 1077 if ( cntSign == 0 ) { 1078 /* all sign bits are decoded now */ 1079 pRemainingBitsInSegment[segmentOffset] -= 1; /* last reinitialzation of for loop counter (see above) is done here */ 1080 1081 /* check decoded values if codeword is decoded: Check if one or two escape sequences 16 follow */ 1082 1083 /* step 0 */ 1084 /* restore pointer to first decoded quantized value [ = original pResultPointr] from index iNode prepared in State_BODY_SIGN_ESC__BODY */ 1085 iQSC = iNode[codewordOffset]; 1086 1087 /* step 1 */ 1088 /* test first value if escape sequence follows */ 1089 flagA = 0; /* for first possible escape sequence */ 1090 if ( fixp_abs(pResultBase[iQSC++]) == (FIXP_DBL)ESCAPE_VALUE ) { 1091 flagA = 1; 1092 } 1093 1094 /* step 2 */ 1095 /* test second value if escape sequence follows */ 1096 flagB = 0; /* for second possible escape sequence */ 1097 if ( fixp_abs(pResultBase[iQSC]) == (FIXP_DBL)ESCAPE_VALUE ) { 1098 flagB = 1; 1099 } 1100 1101 1102 /* step 3 */ 1103 /* evaluate flag result and go on if necessary */ 1104 if ( !flagA && !flagB ) { 1105 ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState), 1106 segmentOffset, 1107 pCodewordBitfield); /* clear a bit in bitfield and switch off statemachine */ 1108 } 1109 else { 1110 /* at least one of two lines is 16 */ 1111 /* store both flags at correct positions in non PCW codeword sideinfo pEscapeSequenceInfo[codewordOffset] */ 1112 flags = 0; 1113 flags = flagA << POSITION_OF_FLAG_A; 1114 flags |= (flagB << POSITION_OF_FLAG_B); 1115 pEscapeSequenceInfo[codewordOffset] = flags; 1116 1117 1118 /* set next state */ 1119 pSta[codewordOffset] = BODY_SIGN_ESC__ESC_PREFIX; 1120 pHcr->nonPcwSideinfo.pState = aStateConstant2State[pSta[codewordOffset]]; /* get state from separate array of cw-sideinfo */ 1121 1122 /* set result pointer to the first line of the two decoded lines */ 1123 iResultPointer[codewordOffset] = iNode[codewordOffset]; 1124 1125 if ( !flagA && flagB ) { 1126 /* update pResultPointr ==> state Stat_BODY_SIGN_ESC__ESC_WORD writes to correct position. Second value is the one and only escape value */ 1127 iQSC = iResultPointer[codewordOffset]; 1128 iQSC++; 1129 iResultPointer[codewordOffset] = iQSC; 1130 } 1131 1132 } /* at least one of two lines is 16 */ 1133 break; /* nonPCW-Body at cb 11 and according sign bits are decoded */ 1134 1135 } /* if ( cntSign == 0 ) */ 1136 } /* loop over remaining Bits in segment */ 1137 1138 if ( pRemainingBitsInSegment[segmentOffset] <= 0 ) { 1139 ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState), 1140 segmentOffset, 1141 pSegmentBitfield); /* clear a bit in bitfield and switch off statemachine */ 1142 1143#if STATE_MACHINE_ERROR_CHECK 1144 if ( pRemainingBitsInSegment[segmentOffset] < 0 ) { 1145 pHcr->decInOut.errorLog |= STATE_ERROR_BODY_SIGN_ESC__SIGN; 1146 return BODY_SIGN_ESC__SIGN; 1147 } 1148#endif 1149 1150 } 1151 return STOP_THIS_STATE; 1152} 1153 1154 1155/*--------------------------------------------------------------------------------------------- 1156 description: Decode escape prefix of first or second escape sequence. The escape prefix 1157 consists of ones. The following zero is also decoded here. 1158----------------------------------------------------------------------------------------------- 1159 output: If the single separator-zero which follows the escape-prefix-ones is not yet decoded: 1160 The value 'escapePrefixUp' in word pEscapeSequenceInfo[codewordOffset] is updated. 1161 1162 If the single separator-zero which follows the escape-prefix-ones is decoded: 1163 Two updated values 'escapePrefixUp' and 'escapePrefixDown' in word 1164 pEscapeSequenceInfo[codewordOffset]. This State is finished. Switch to next state. 1165----------------------------------------------------------------------------------------------- 1166 return: 0 1167-------------------------------------------------------------------------------------------- */ 1168UINT Hcr_State_BODY_SIGN_ESC__ESC_PREFIX(HANDLE_FDK_BITSTREAM bs, void *ptr) 1169{ 1170 H_HCR_INFO pHcr = (H_HCR_INFO)ptr; 1171 SCHAR *pRemainingBitsInSegment; 1172 USHORT *pLeftStartOfSegment; 1173 USHORT *pRightStartOfSegment; 1174 UCHAR readDirection; 1175 UINT *pSegmentBitfield; 1176 UINT segmentOffset; 1177 UINT *pEscapeSequenceInfo; 1178 UINT codewordOffset; 1179 UCHAR carryBit; 1180 UINT escapePrefixUp; 1181 SCHAR *pSta; 1182 1183 pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment; 1184 pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment; 1185 pRightStartOfSegment = pHcr->segmentInfo.pRightStartOfSegment; 1186 readDirection = pHcr->segmentInfo.readDirection; 1187 pSegmentBitfield = pHcr->segmentInfo.pSegmentBitfield; 1188 segmentOffset = pHcr->segmentInfo.segmentOffset; 1189 pEscapeSequenceInfo = pHcr->nonPcwSideinfo.pEscapeSequenceInfo; 1190 codewordOffset = pHcr->nonPcwSideinfo.codewordOffset; 1191 pSta = pHcr->nonPcwSideinfo.pSta; 1192 1193 escapePrefixUp = (pEscapeSequenceInfo[codewordOffset] & MASK_ESCAPE_PREFIX_UP) >> LSB_ESCAPE_PREFIX_UP; 1194 1195 1196 /* decode escape prefix */ 1197 for ( ; pRemainingBitsInSegment[segmentOffset] > 0 ; pRemainingBitsInSegment[segmentOffset] -= 1 ) { 1198 1199 carryBit = HcrGetABitFromBitstream( bs, 1200 &pLeftStartOfSegment[segmentOffset], 1201 &pRightStartOfSegment[segmentOffset], 1202 readDirection); 1203 1204 /* count ones and store sum in escapePrefixUp */ 1205 if ( carryBit == 1 ) { 1206 escapePrefixUp += 1; /* update conter for ones */ 1207 1208 /* store updated counter in sideinfo of current codeword */ 1209 pEscapeSequenceInfo[codewordOffset] &= ~MASK_ESCAPE_PREFIX_UP; /* delete old escapePrefixUp */ 1210 escapePrefixUp <<= LSB_ESCAPE_PREFIX_UP; /* shift to correct position */ 1211 pEscapeSequenceInfo[codewordOffset] |= escapePrefixUp; /* insert new escapePrefixUp */ 1212 escapePrefixUp >>= LSB_ESCAPE_PREFIX_UP; /* shift back down */ 1213 } 1214 else { /* separator [zero] reached */ 1215 pRemainingBitsInSegment[segmentOffset] -= 1; /* last reinitialzation of for loop counter (see above) is done here */ 1216 escapePrefixUp += 4; /* if escape_separator '0' appears, add 4 and ==> break */ 1217 1218 /* store escapePrefixUp in pEscapeSequenceInfo[codewordOffset] at bit position escapePrefixUp */ 1219 pEscapeSequenceInfo[codewordOffset] &= ~MASK_ESCAPE_PREFIX_UP; /* delete old escapePrefixUp */ 1220 escapePrefixUp <<= LSB_ESCAPE_PREFIX_UP; /* shift to correct position */ 1221 pEscapeSequenceInfo[codewordOffset] |= escapePrefixUp; /* insert new escapePrefixUp */ 1222 escapePrefixUp >>= LSB_ESCAPE_PREFIX_UP; /* shift back down */ 1223 1224 /* store escapePrefixUp in pEscapeSequenceInfo[codewordOffset] at bit position escapePrefixDown */ 1225 pEscapeSequenceInfo[codewordOffset] &= ~MASK_ESCAPE_PREFIX_DOWN; /* delete old escapePrefixDown */ 1226 escapePrefixUp <<= LSB_ESCAPE_PREFIX_DOWN; /* shift to correct position */ 1227 pEscapeSequenceInfo[codewordOffset] |= escapePrefixUp; /* insert new escapePrefixDown */ 1228 escapePrefixUp >>= LSB_ESCAPE_PREFIX_DOWN; /* shift back down */ 1229 1230 pSta[codewordOffset] = BODY_SIGN_ESC__ESC_WORD; /* set next state */ 1231 pHcr->nonPcwSideinfo.pState = aStateConstant2State[pSta[codewordOffset]]; /* get state from separate array of cw-sideinfo */ 1232 break; 1233 } 1234 } 1235 1236 if ( pRemainingBitsInSegment[segmentOffset] <= 0 ) { 1237 ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState), 1238 segmentOffset, 1239 pSegmentBitfield); /* clear a bit in bitfield and switch off statemachine */ 1240 1241#if STATE_MACHINE_ERROR_CHECK 1242 if ( pRemainingBitsInSegment[segmentOffset] < 0 ) { 1243 pHcr->decInOut.errorLog |= STATE_ERROR_BODY_SIGN_ESC__ESC_PREFIX; 1244 return BODY_SIGN_ESC__ESC_PREFIX; 1245 } 1246#endif 1247 } 1248 1249 return STOP_THIS_STATE; 1250} 1251 1252 1253/*--------------------------------------------------------------------------------------------- 1254 description: Decode escapeWord of escape sequence. If the escape sequence is decoded 1255 completely, assemble quantized-spectral-escape-coefficient and replace the 1256 previous decoded 16 by the new value. 1257 Test flagB. If flagB is set, the second escape sequence must be decoded. If 1258 flagB is not set, the codeword is decoded and the state machine is switched 1259 off. 1260----------------------------------------------------------------------------------------------- 1261 output: Two lines with valid sign. At least one of both lines has got the correct 1262 value. 1263----------------------------------------------------------------------------------------------- 1264 return: 0 1265-------------------------------------------------------------------------------------------- */ 1266UINT Hcr_State_BODY_SIGN_ESC__ESC_WORD(HANDLE_FDK_BITSTREAM bs, void *ptr) 1267{ 1268 H_HCR_INFO pHcr = (H_HCR_INFO)ptr; 1269 SCHAR *pRemainingBitsInSegment; 1270 USHORT *pLeftStartOfSegment; 1271 USHORT *pRightStartOfSegment; 1272 UCHAR readDirection; 1273 UINT *pSegmentBitfield; 1274 UINT *pCodewordBitfield; 1275 UINT segmentOffset; 1276 1277 FIXP_DBL *pResultBase; 1278 USHORT *iResultPointer; 1279 UINT *pEscapeSequenceInfo; 1280 UINT codewordOffset; 1281 1282 UINT escapeWord; 1283 UINT escapePrefixDown; 1284 UINT escapePrefixUp; 1285 UCHAR carryBit; 1286 UINT iQSC; 1287 INT sign; 1288 UINT flagA; 1289 UINT flagB; 1290 SCHAR *pSta; 1291 1292 pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment; 1293 pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment; 1294 pRightStartOfSegment = pHcr->segmentInfo.pRightStartOfSegment; 1295 readDirection = pHcr->segmentInfo.readDirection; 1296 pSegmentBitfield = pHcr->segmentInfo.pSegmentBitfield; 1297 pCodewordBitfield = pHcr->segmentInfo.pCodewordBitfield; 1298 segmentOffset = pHcr->segmentInfo.segmentOffset; 1299 1300 pResultBase = pHcr->nonPcwSideinfo.pResultBase; 1301 iResultPointer = pHcr->nonPcwSideinfo.iResultPointer; 1302 pEscapeSequenceInfo = pHcr->nonPcwSideinfo.pEscapeSequenceInfo; 1303 codewordOffset = pHcr->nonPcwSideinfo.codewordOffset; 1304 pSta = pHcr->nonPcwSideinfo.pSta; 1305 1306 escapeWord = pEscapeSequenceInfo[codewordOffset] & MASK_ESCAPE_WORD; 1307 escapePrefixDown = (pEscapeSequenceInfo[codewordOffset] & MASK_ESCAPE_PREFIX_DOWN) >> LSB_ESCAPE_PREFIX_DOWN; 1308 1309 1310 /* decode escape word */ 1311 for ( ; pRemainingBitsInSegment[segmentOffset] > 0 ; pRemainingBitsInSegment[segmentOffset] -= 1 ) { 1312 1313 carryBit = HcrGetABitFromBitstream( bs, 1314 &pLeftStartOfSegment[segmentOffset], 1315 &pRightStartOfSegment[segmentOffset], 1316 readDirection); 1317 1318 /* build escape word */ 1319 escapeWord <<= 1; /* left shift previous decoded part of escapeWord by on bit */ 1320 escapeWord = escapeWord | carryBit; /* assemble escape word by bitwise or */ 1321 1322 /* decrement counter for length of escape word because one more bit was decoded */ 1323 escapePrefixDown -= 1; 1324 1325 /* store updated escapePrefixDown */ 1326 pEscapeSequenceInfo[codewordOffset] &= ~MASK_ESCAPE_PREFIX_DOWN; /* delete old escapePrefixDown */ 1327 escapePrefixDown <<= LSB_ESCAPE_PREFIX_DOWN; /* shift to correct position */ 1328 pEscapeSequenceInfo[codewordOffset] |= escapePrefixDown; /* insert new escapePrefixDown */ 1329 escapePrefixDown >>= LSB_ESCAPE_PREFIX_DOWN; /* shift back */ 1330 1331 1332 /* store updated escapeWord */ 1333 pEscapeSequenceInfo[codewordOffset] &= ~MASK_ESCAPE_WORD; /* delete old escapeWord */ 1334 pEscapeSequenceInfo[codewordOffset] |= escapeWord; /* insert new escapeWord */ 1335 1336 1337 if ( escapePrefixDown == 0 ) { 1338 pRemainingBitsInSegment[segmentOffset] -= 1; /* last reinitialzation of for loop counter (see above) is done here */ 1339 1340 /* escape sequence decoded. Assemble escape-line and replace original line */ 1341 1342 /* step 0 */ 1343 /* derive sign */ 1344 iQSC = iResultPointer[codewordOffset]; 1345 sign = (pResultBase[iQSC] >= (FIXP_DBL)0) ? 1 : -1; /* get sign of escape value 16 */ 1346 1347 /* step 1 */ 1348 /* get escapePrefixUp */ 1349 escapePrefixUp = (pEscapeSequenceInfo[codewordOffset] & MASK_ESCAPE_PREFIX_UP) >> LSB_ESCAPE_PREFIX_UP; 1350 1351 /* step 2 */ 1352 /* calculate escape value */ 1353 pResultBase[iQSC] = (FIXP_DBL)(sign * (((INT) 1 << escapePrefixUp) + escapeWord)); 1354 1355 /* get both flags from sideinfo (flags are not shifted to the lsb-position) */ 1356 flagA = pEscapeSequenceInfo[codewordOffset] & MASK_FLAG_A; 1357 flagB = pEscapeSequenceInfo[codewordOffset] & MASK_FLAG_B; 1358 1359 /* step 3 */ 1360 /* clear the whole escape sideinfo word */ 1361 pEscapeSequenceInfo[codewordOffset] = 0; 1362 1363 /* change state in dependence of flag flagB */ 1364 if ( flagA != 0 ) { 1365 /* first escape sequence decoded; previous decoded 16 has been replaced by valid line */ 1366 1367 /* clear flagA in sideinfo word because this escape sequence has already beed decoded */ 1368 pEscapeSequenceInfo[codewordOffset] &= ~MASK_FLAG_A; 1369 1370 if ( flagB == 0 ) { 1371 ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState), 1372 segmentOffset, 1373 pCodewordBitfield); /* clear a bit in bitfield and switch off statemachine */ 1374 } 1375 else { 1376 /* updated pointer to next and last 16 */ 1377 iQSC++; 1378 iResultPointer[codewordOffset] = iQSC; 1379 1380 /* change state */ 1381 pSta[codewordOffset] = BODY_SIGN_ESC__ESC_PREFIX; 1382 pHcr->nonPcwSideinfo.pState = aStateConstant2State[pSta[codewordOffset]]; /* get state from separate array of cw-sideinfo */ 1383 } 1384 } 1385 else { 1386 ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState), 1387 segmentOffset, 1388 pCodewordBitfield); /* clear a bit in bitfield and switch off statemachine */ 1389 } 1390 break; 1391 } 1392 } 1393 1394 if ( pRemainingBitsInSegment[segmentOffset] <= 0 ) { 1395 ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState), 1396 segmentOffset, 1397 pSegmentBitfield); /* clear a bit in bitfield and switch off statemachine */ 1398 1399#if STATE_MACHINE_ERROR_CHECK 1400 if ( pRemainingBitsInSegment[segmentOffset] < 0 ) { 1401 pHcr->decInOut.errorLog |= STATE_ERROR_BODY_SIGN_ESC__ESC_WORD; 1402 return BODY_SIGN_ESC__ESC_WORD; 1403 } 1404#endif 1405 } 1406 1407 return STOP_THIS_STATE; 1408} 1409 1410