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