repositories / deb_fdk-aac.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Imported Debian version 0.1.3.1
[deb_fdk-aac.git] / libAACenc / src / dyn_bits.cpp
1
2 /* -----------------------------------------------------------------------------------------------------------
3 Software License for The Fraunhofer FDK AAC Codec Library for Android
4
5 © Copyright 1995 - 2013 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V.
6 All rights reserved.
7
8 1. INTRODUCTION
9 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
10 the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
11 This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
12
13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
14 audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
15 independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
16 of the MPEG specifications.
17
18 Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
19 may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
20 individually for the purpose of encoding or decoding bit streams in products that are compliant with
21 the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
22 these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
23 software may already be covered under those patent licenses when it is used for those licensed purposes only.
24
25 Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
26 are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
27 applications information and documentation.
28
29 2. COPYRIGHT LICENSE
30
31 Redistribution and use in source and binary forms, with or without modification, are permitted without
32 payment of copyright license fees provided that you satisfy the following conditions:
33
34 You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
35 your modifications thereto in source code form.
36
37 You must retain the complete text of this software license in the documentation and/or other materials
38 provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
39 You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
40 modifications thereto to recipients of copies in binary form.
41
42 The name of Fraunhofer may not be used to endorse or promote products derived from this library without
43 prior written permission.
44
45 You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
46 software or your modifications thereto.
47
48 Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
49 and the date of any change. For modified versions of the FDK AAC Codec, the term
50 "Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
51 "Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
52
53 3. NO PATENT LICENSE
54
55 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
56 ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
57 respect to this software.
58
59 You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
60 by appropriate patent licenses.
61
62 4. DISCLAIMER
63
64 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
65 "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
66 of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
67 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
68 including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
69 or business interruption, however caused and on any theory of liability, whether in contract, strict
70 liability, or tort (including negligence), arising in any way out of the use of this software, even if
71 advised of the possibility of such damage.
72
73 5. CONTACT INFORMATION
74
75 Fraunhofer Institute for Integrated Circuits IIS
76 Attention: Audio and Multimedia Departments - FDK AAC LL
77 Am Wolfsmantel 33
78 91058 Erlangen, Germany
79
80 www.iis.fraunhofer.de/amm
81 amm-info@iis.fraunhofer.de
82 ----------------------------------------------------------------------------------------------------------- */
83
84 /******************************** MPEG Audio Encoder **************************
85
86 Initial author: M.Werner
87 contents/description: Noiseless coder module
88
89 ******************************************************************************/
90
91 #include "dyn_bits.h"
92 #include "bit_cnt.h"
93 #include "psy_const.h"
94 #include "aacenc_pns.h"
95 #include "aacEnc_ram.h"
96 #include "aacEnc_rom.h"
97
98 typedef INT (*lookUpTable)[CODE_BOOK_ESC_NDX + 1];
99
100 static INT FDKaacEnc_getSideInfoBits(
101 const SECTION_INFO* const huffsection,
102 const SHORT* const sideInfoTab,
103 const INT useHCR
104 )
105 {
106 INT sideInfoBits;
107
108 if ( useHCR && ((huffsection->codeBook == 11) || (huffsection->codeBook >= 16)) ) {
109 sideInfoBits = 5;
110 }
111 else {
112 sideInfoBits = sideInfoTab[huffsection->sfbCnt];
113 }
114
115 return (sideInfoBits);
116 }
117
118 /* count bits using all possible tables */
119 static void FDKaacEnc_buildBitLookUp(
120 const SHORT* const quantSpectrum,
121 const INT maxSfb,
122 const INT* const sfbOffset,
123 const UINT* const sfbMax,
124 INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1],
125 SECTION_INFO* const huffsection
126 )
127 {
128 INT i, sfbWidth;
129
130 for (i = 0; i < maxSfb; i++)
131 {
132 huffsection[i].sfbCnt = 1;
133 huffsection[i].sfbStart = i;
134 huffsection[i].sectionBits = INVALID_BITCOUNT;
135 huffsection[i].codeBook = -1;
136 sfbWidth = sfbOffset[i + 1] - sfbOffset[i];
137 FDKaacEnc_bitCount(quantSpectrum + sfbOffset[i], sfbWidth, sfbMax[i], bitLookUp[i]);
138 }
139 }
140
141 /* essential helper functions */
142 static INT FDKaacEnc_findBestBook(
143 const INT* const bc,
144 INT* const book,
145 const INT useVCB11
146 )
147 {
148 INT minBits = INVALID_BITCOUNT, j;
149
150 int end = CODE_BOOK_ESC_NDX;
151
152
153 for (j = 0; j <= end; j++)
154 {
155 if (bc[j] < minBits)
156 {
157 minBits = bc[j];
158 *book = j;
159 }
160 }
161 return (minBits);
162 }
163
164 static INT FDKaacEnc_findMinMergeBits(
165 const INT* const bc1,
166 const INT* const bc2,
167 const INT useVCB11
168 )
169 {
170 INT minBits = INVALID_BITCOUNT, j;
171
172 int end = CODE_BOOK_ESC_NDX;
173
174
175 for (j = 0; j <= end; j++)
176 {
177 if (bc1[j] + bc2[j] < minBits)
178 {
179 minBits = bc1[j] + bc2[j];
180 }
181 }
182 return (minBits);
183 }
184
185 static void FDKaacEnc_mergeBitLookUp(
186 INT* const bc1,
187 const INT* const bc2
188 )
189 {
190 int j;
191
192 for (j = 0; j <= CODE_BOOK_ESC_NDX; j++)
193 {
194 bc1[j] = fixMin(bc1[j] + bc2[j], INVALID_BITCOUNT);
195 }
196 }
197
198 static INT FDKaacEnc_findMaxMerge(
199 const INT* const mergeGainLookUp,
200 const SECTION_INFO* const huffsection,
201 const INT maxSfb,
202 INT* const maxNdx
203 )
204 {
205 INT i, maxMergeGain = 0;
206
207 for (i = 0; i + huffsection[i].sfbCnt < maxSfb; i += huffsection[i].sfbCnt)
208 {
209 if (mergeGainLookUp[i] > maxMergeGain)
210 {
211 maxMergeGain = mergeGainLookUp[i];
212 *maxNdx = i;
213 }
214 }
215 return (maxMergeGain);
216 }
217
218 static INT FDKaacEnc_CalcMergeGain(
219 const SECTION_INFO* const huffsection,
220 const INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1],
221 const SHORT* const sideInfoTab,
222 const INT ndx1,
223 const INT ndx2,
224 const INT useVCB11
225 )
226 {
227 INT MergeGain, MergeBits, SplitBits;
228
229 MergeBits = sideInfoTab[huffsection[ndx1].sfbCnt + huffsection[ndx2].sfbCnt] + FDKaacEnc_findMinMergeBits(bitLookUp[ndx1], bitLookUp[ndx2], useVCB11);
230 SplitBits = huffsection[ndx1].sectionBits + huffsection[ndx2].sectionBits; /* Bit amount for splitted huffsections */
231 MergeGain = SplitBits - MergeBits;
232
233 if ( (huffsection[ndx1].codeBook==CODE_BOOK_PNS_NO)||(huffsection[ndx2].codeBook==CODE_BOOK_PNS_NO)
234 || (huffsection[ndx1].codeBook==CODE_BOOK_IS_OUT_OF_PHASE_NO)||(huffsection[ndx2].codeBook==CODE_BOOK_IS_OUT_OF_PHASE_NO)
235 || (huffsection[ndx1].codeBook==CODE_BOOK_IS_IN_PHASE_NO)||(huffsection[ndx2].codeBook==CODE_BOOK_IS_IN_PHASE_NO)
236 )
237 {
238 MergeGain = -1;
239 }
240
241 return (MergeGain);
242 }
243
244
245 /* sectioning Stage 0:find minimum codbooks */
246 static void FDKaacEnc_gmStage0(
247 SECTION_INFO* const RESTRICT huffsection,
248 const INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1],
249 const INT maxSfb,
250 const INT* const noiseNrg,
251 const INT* const isBook
252 )
253 {
254 INT i;
255
256 for (i = 0; i < maxSfb; i++)
257 {
258 /* Side-Info bits will be calculated in Stage 1! */
259 if (huffsection[i].sectionBits == INVALID_BITCOUNT)
260 {
261 /* intensity and pns codebooks are already allocated in bitcount.c */
262 if(noiseNrg[i] != NO_NOISE_PNS){
263 huffsection[i].codeBook=CODE_BOOK_PNS_NO;
264 huffsection[i].sectionBits = 0;
265 }
266 else if( isBook[i] ) {
267 huffsection[i].codeBook=isBook[i];
268 huffsection[i].sectionBits = 0;
269 }
270 else {
271 huffsection[i].sectionBits = FDKaacEnc_findBestBook(bitLookUp[i], &(huffsection[i].codeBook), 0); /* useVCB11 must be 0!!! */
272 }
273 }
274 }
275 }
276
277 /*
278 sectioning Stage 1:merge all connected regions with the same code book and
279 calculate side info
280 */
281 static void FDKaacEnc_gmStage1(
282 SECTION_INFO* const RESTRICT huffsection,
283 INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1],
284 const INT maxSfb,
285 const SHORT* const sideInfoTab,
286 const INT useVCB11
287 )
288 {
289 INT mergeStart = 0, mergeEnd;
290
291 do
292 {
293 for (mergeEnd = mergeStart + 1; mergeEnd < maxSfb; mergeEnd++)
294 {
295 if (huffsection[mergeStart].codeBook != huffsection[mergeEnd].codeBook)
296 break;
297
298
299 /* we can merge. update tables, side info bits will be updated outside of this loop */
300 huffsection[mergeStart].sfbCnt++;
301 huffsection[mergeStart].sectionBits += huffsection[mergeEnd].sectionBits;
302
303 /* update bit look up for all code books */
304 FDKaacEnc_mergeBitLookUp(bitLookUp[mergeStart], bitLookUp[mergeEnd]);
305 }
306
307 /* add side info info bits */
308 huffsection[mergeStart].sectionBits += FDKaacEnc_getSideInfoBits(&huffsection[mergeStart], sideInfoTab, useVCB11);
309 huffsection[mergeEnd - 1].sfbStart = huffsection[mergeStart].sfbStart; /* speed up prev search */
310
311 mergeStart = mergeEnd;
312
313 } while (mergeStart < maxSfb);
314 }
315
316 /*
317 sectioning Stage 2:greedy merge algorithm, merge connected sections with
318 maximum bit gain until no more gain is possible
319 */
320 static void
321 FDKaacEnc_gmStage2(
322 SECTION_INFO* const RESTRICT huffsection,
323 INT* const RESTRICT mergeGainLookUp,
324 INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1],
325 const INT maxSfb,
326 const SHORT* const sideInfoTab,
327 const INT useVCB11
328 )
329 {
330 INT i;
331
332 for (i = 0; i + huffsection[i].sfbCnt < maxSfb; i += huffsection[i].sfbCnt)
333 {
334 mergeGainLookUp[i] = FDKaacEnc_CalcMergeGain(huffsection,
335 bitLookUp,
336 sideInfoTab,
337 i,
338 i + huffsection[i].sfbCnt,
339 useVCB11);
340 }
341
342 while (TRUE)
343 {
344 INT maxMergeGain, maxNdx = 0, maxNdxNext, maxNdxLast;
345
346 maxMergeGain = FDKaacEnc_findMaxMerge(mergeGainLookUp, huffsection, maxSfb, &maxNdx);
347
348 /* exit while loop if no more gain is possible */
349 if (maxMergeGain <= 0)
350 break;
351
352 maxNdxNext = maxNdx + huffsection[maxNdx].sfbCnt;
353
354 /* merge sections with maximum bit gain */
355 huffsection[maxNdx].sfbCnt += huffsection[maxNdxNext].sfbCnt;
356 huffsection[maxNdx].sectionBits += huffsection[maxNdxNext].sectionBits - maxMergeGain;
357
358 /* update bit look up table for merged huffsection */
359 FDKaacEnc_mergeBitLookUp(bitLookUp[maxNdx], bitLookUp[maxNdxNext]);
360
361 /* update mergeLookUpTable */
362 if (maxNdx != 0)
363 {
364 maxNdxLast = huffsection[maxNdx - 1].sfbStart;
365 mergeGainLookUp[maxNdxLast] = FDKaacEnc_CalcMergeGain(huffsection,
366 bitLookUp,
367 sideInfoTab,
368 maxNdxLast,
369 maxNdx,
370 useVCB11);
371
372 }
373 maxNdxNext = maxNdx + huffsection[maxNdx].sfbCnt;
374
375 huffsection[maxNdxNext - 1].sfbStart = huffsection[maxNdx].sfbStart;
376
377 if (maxNdxNext < maxSfb)
378 mergeGainLookUp[maxNdx] = FDKaacEnc_CalcMergeGain(huffsection,
379 bitLookUp,
380 sideInfoTab,
381 maxNdx,
382 maxNdxNext,
383 useVCB11);
384
385 }
386 }
387
388 /* count bits used by the noiseless coder */
389 static void FDKaacEnc_noiselessCounter(
390 SECTION_DATA* const RESTRICT sectionData,
391 INT mergeGainLookUp[MAX_SFB_LONG],
392 INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1],
393 const SHORT* const quantSpectrum,
394 const UINT* const maxValueInSfb,
395 const INT* const sfbOffset,
396 const INT blockType,
397 const INT* const noiseNrg,
398 const INT* const isBook,
399 const INT useVCB11
400 )
401 {
402 INT grpNdx, i;
403 const SHORT *sideInfoTab = NULL;
404 SECTION_INFO *huffsection;
405
406 /* use appropriate side info table */
407 switch (blockType)
408 {
409 case LONG_WINDOW:
410 case START_WINDOW:
411 case STOP_WINDOW:
412 sideInfoTab = FDKaacEnc_sideInfoTabLong;
413 break;
414 case SHORT_WINDOW:
415 sideInfoTab = FDKaacEnc_sideInfoTabShort;
416 break;
417 }
418
419 sectionData->noOfSections = 0;
420 sectionData->huffmanBits = 0;
421 sectionData->sideInfoBits = 0;
422
423
424 if (sectionData->maxSfbPerGroup == 0)
425 return;
426
427 /* loop trough groups */
428 for (grpNdx = 0; grpNdx < sectionData->sfbCnt; grpNdx += sectionData->sfbPerGroup)
429 {
430 huffsection = sectionData->huffsection + sectionData->noOfSections;
431
432 /* count bits in this group */
433 FDKaacEnc_buildBitLookUp(quantSpectrum,
434 sectionData->maxSfbPerGroup,
435 sfbOffset + grpNdx,
436 maxValueInSfb + grpNdx,
437 bitLookUp,
438 huffsection);
439
440 /* 0.Stage :Find minimum Codebooks */
441 FDKaacEnc_gmStage0(huffsection, bitLookUp, sectionData->maxSfbPerGroup, noiseNrg+grpNdx, isBook+grpNdx);
442
443 /* 1.Stage :Merge all connected regions with the same code book */
444 FDKaacEnc_gmStage1(huffsection, bitLookUp, sectionData->maxSfbPerGroup, sideInfoTab, useVCB11);
445
446
447 /*
448 2.Stage
449 greedy merge algorithm, merge connected huffsections with maximum bit
450 gain until no more gain is possible
451 */
452
453 FDKaacEnc_gmStage2(huffsection,
454 mergeGainLookUp,
455 bitLookUp,
456 sectionData->maxSfbPerGroup,
457 sideInfoTab,
458 useVCB11);
459
460
461
462 /*
463 compress output, calculate total huff and side bits
464 since we did not update the actual codebook in stage 2
465 to save time, we must set it here for later use in bitenc
466 */
467
468 for (i = 0; i < sectionData->maxSfbPerGroup; i += huffsection[i].sfbCnt)
469 {
470 if ((huffsection[i].codeBook==CODE_BOOK_PNS_NO) ||
471 (huffsection[i].codeBook==CODE_BOOK_IS_OUT_OF_PHASE_NO) ||
472 (huffsection[i].codeBook==CODE_BOOK_IS_IN_PHASE_NO))
473 {
474 huffsection[i].sectionBits=0;
475 } else {
476 /* the sections in the sectionData are now marked with the optimal code book */
477
478 FDKaacEnc_findBestBook(bitLookUp[i], &(huffsection[i].codeBook), useVCB11);
479
480 sectionData->huffmanBits += huffsection[i].sectionBits - FDKaacEnc_getSideInfoBits(&huffsection[i], sideInfoTab, useVCB11);
481 }
482
483 huffsection[i].sfbStart += grpNdx;
484
485 /* sum up side info bits (section data bits) */
486 sectionData->sideInfoBits += FDKaacEnc_getSideInfoBits(&huffsection[i], sideInfoTab, useVCB11);
487 sectionData->huffsection[sectionData->noOfSections++] = huffsection[i];
488 }
489 }
490 }
491
492
493 /*******************************************************************************
494
495 functionname: FDKaacEnc_scfCount
496 returns : ---
497 description : count bits used by scalefactors.
498
499 not in all cases if maxValueInSfb[] == 0 we set deltaScf
500 to zero. only if the difference of the last and future
501 scalefacGain is not greater then CODE_BOOK_SCF_LAV (60).
502
503 example:
504 ^
505 scalefacGain |
506 |
507 | last 75
508 | |
509 | |
510 | |
511 | | current 50
512 | | |
513 | | |
514 | | |
515 | | |
516 | | | future 5
517 | | | |
518 --- ... ---------------------------- ... --------->
519 sfb
520
521
522 if maxValueInSfb[] of current is zero because of a
523 notfallstrategie, we do not save bits and transmit a
524 deltaScf of 25. otherwise the deltaScf between the last
525 scalfacGain (75) and the future scalefacGain (5) is 70.
526
527 ********************************************************************************/
528 static void FDKaacEnc_scfCount(
529 const INT* const scalefacGain,
530 const UINT* const maxValueInSfb,
531 SECTION_DATA* const RESTRICT sectionData,
532 const INT* const isScale
533 )
534 {
535 INT i, j, k, m, n;
536
537 INT lastValScf = 0;
538 INT deltaScf = 0;
539 INT found = 0;
540 INT scfSkipCounter = 0;
541 INT lastValIs = 0;
542
543 sectionData->scalefacBits = 0;
544
545 if (scalefacGain == NULL)
546 return;
547
548 sectionData->firstScf = 0;
549
550 for (i=0; i<sectionData->noOfSections; i++)
551 {
552 if (sectionData->huffsection[i].codeBook != CODE_BOOK_ZERO_NO)
553 {
554 sectionData->firstScf = sectionData->huffsection[i].sfbStart;
555 lastValScf = scalefacGain[sectionData->firstScf];
556 break;
557 }
558 }
559
560 for (i=0; i<sectionData->noOfSections; i++)
561 {
562 if ((sectionData->huffsection[i].codeBook == CODE_BOOK_IS_OUT_OF_PHASE_NO) ||
563 (sectionData->huffsection[i].codeBook == CODE_BOOK_IS_IN_PHASE_NO))
564 {
565 for (j = sectionData->huffsection[i].sfbStart;
566 j < sectionData->huffsection[i].sfbStart + sectionData->huffsection[i].sfbCnt;
567 j++)
568 {
569 INT deltaIs = isScale[j]-lastValIs;
570 lastValIs = isScale[j];
571 sectionData->scalefacBits+=FDKaacEnc_bitCountScalefactorDelta(deltaIs);
572 }
573 } /* Intensity */
574 else if ((sectionData->huffsection[i].codeBook != CODE_BOOK_ZERO_NO) &&
575 (sectionData->huffsection[i].codeBook != CODE_BOOK_PNS_NO))
576 {
577 INT tmp = sectionData->huffsection[i].sfbStart + sectionData->huffsection[i].sfbCnt;
578 for (j = sectionData->huffsection[i].sfbStart; j<tmp; j++)
579 {
580 /* check if we can repeat the last value to save bits */
581 if (maxValueInSfb[j] == 0)
582 {
583 found = 0;
584 /* are scalefactors skipped? */
585 if (scfSkipCounter == 0)
586 {
587 /* end of section */
588 if (j == (tmp - 1) )
589 found = 0; /* search in other sections for maxValueInSfb != 0 */
590 else
591 {
592 /* search in this section for the next maxValueInSfb[] != 0 */
593 for (k = (j+1); k < tmp; k++)
594 {
595 if (maxValueInSfb[k] != 0)
596 {
597 found = 1;
598 if ( (fixp_abs(scalefacGain[k] - lastValScf)) <= CODE_BOOK_SCF_LAV)
599 deltaScf = 0; /* save bits */
600 else
601 {
602 /* do not save bits */
603 deltaScf = lastValScf - scalefacGain[j];
604 lastValScf = scalefacGain[j];
605 scfSkipCounter = 0;
606 }
607 break;
608 }
609 /* count scalefactor skip */
610 scfSkipCounter++;
611 }
612 }
613
614 /* search for the next maxValueInSfb[] != 0 in all other sections */
615 for (m=(i+1); (m < sectionData->noOfSections) && (found == 0); m++)
616 {
617 if ((sectionData->huffsection[m].codeBook != CODE_BOOK_ZERO_NO) && (sectionData->huffsection[m].codeBook != CODE_BOOK_PNS_NO))
618 {
619 INT end = sectionData->huffsection[m].sfbStart + sectionData->huffsection[m].sfbCnt;
620 for (n = sectionData->huffsection[m].sfbStart; n<end; n++)
621 {
622 if (maxValueInSfb[n] != 0)
623 {
624 found = 1;
625 if (fixp_abs(scalefacGain[n] - lastValScf) <= CODE_BOOK_SCF_LAV)
626 deltaScf = 0; /* save bits */
627 else
628 {
629 /* do not save bits */
630 deltaScf = lastValScf - scalefacGain[j];
631 lastValScf = scalefacGain[j];
632 scfSkipCounter = 0;
633 }
634 break;
635 }
636 /* count scalefactor skip */
637 scfSkipCounter++;
638 }
639 }
640 }
641 /* no maxValueInSfb[] != 0 found */
642 if (found == 0)
643 {
644 deltaScf = 0;
645 scfSkipCounter = 0;
646 }
647 }
648 else {
649 /* consider skipped scalefactors */
650 deltaScf = 0;
651 scfSkipCounter--;
652 }
653 }
654 else {
655 deltaScf = lastValScf - scalefacGain[j];
656 lastValScf = scalefacGain[j];
657 }
658 sectionData->scalefacBits += FDKaacEnc_bitCountScalefactorDelta(deltaScf);
659 }
660 }
661 } /* for (i=0; i<sectionData->noOfSections; i++) */
662 }
663
664 #ifdef PNS_PRECOUNT_ENABLE
665 /*
666 preCount bits used pns
667 */
668 /* estimate bits used by pns for correction of static bits */
669 /* no codebook switch estimation, see AAC LD FASTENC */
670 INT noisePreCount(const INT *noiseNrg, INT maxSfb)
671 {
672 INT noisePCMFlag = TRUE;
673 INT lastValPns = 0, deltaPns;
674 int i, bits=0;
675
676 for (i = 0; i < maxSfb; i++) {
677 if (noiseNrg[i] != NO_NOISE_PNS) {
678
679 if (noisePCMFlag) {
680 bits+=PNS_PCM_BITS;
681 lastValPns = noiseNrg[i];
682 noisePCMFlag = FALSE;
683 }else {
684 deltaPns = noiseNrg[i]-lastValPns;
685 lastValPns = noiseNrg[i];
686 bits+=FDKaacEnc_bitCountScalefactorDelta(deltaPns);
687 }
688 }
689 }
690 return ( bits );
691 }
692 #endif /* PNS_PRECOUNT_ENABLE */
693
694 /* count bits used by pns */
695 static void FDKaacEnc_noiseCount(
696 SECTION_DATA* const RESTRICT sectionData,
697 const INT* const noiseNrg
698 )
699 {
700 INT noisePCMFlag = TRUE;
701 INT lastValPns = 0, deltaPns;
702 int i, j;
703
704 sectionData->noiseNrgBits = 0;
705
706 for (i = 0; i < sectionData->noOfSections; i++) {
707 if (sectionData->huffsection[i].codeBook == CODE_BOOK_PNS_NO) {
708 int sfbStart = sectionData->huffsection[i].sfbStart;
709 int sfbEnd = sfbStart + sectionData->huffsection[i].sfbCnt;
710 for (j=sfbStart; j<sfbEnd; j++) {
711
712 if (noisePCMFlag) {
713 sectionData->noiseNrgBits+=PNS_PCM_BITS;
714 lastValPns = noiseNrg[j];
715 noisePCMFlag = FALSE;
716 } else {
717 deltaPns = noiseNrg[j]-lastValPns;
718 lastValPns = noiseNrg[j];
719 sectionData->noiseNrgBits+=FDKaacEnc_bitCountScalefactorDelta(deltaPns);
720 }
721 }
722 }
723 }
724 }
725
726 INT FDKaacEnc_dynBitCount(
727 BITCNTR_STATE* const hBC,
728 const SHORT* const quantSpectrum,
729 const UINT* const maxValueInSfb,
730 const INT* const scalefac,
731 const INT blockType,
732 const INT sfbCnt,
733 const INT maxSfbPerGroup,
734 const INT sfbPerGroup,
735 const INT* const sfbOffset,
736 SECTION_DATA* const RESTRICT sectionData,
737 const INT* const noiseNrg,
738 const INT* const isBook,
739 const INT* const isScale,
740 const UINT syntaxFlags
741 )
742 {
743 sectionData->blockType = blockType;
744 sectionData->sfbCnt = sfbCnt;
745 sectionData->sfbPerGroup = sfbPerGroup;
746 sectionData->noOfGroups = sfbCnt / sfbPerGroup;
747 sectionData->maxSfbPerGroup = maxSfbPerGroup;
748
749 FDKaacEnc_noiselessCounter(
750 sectionData,
751 hBC->mergeGainLookUp,
752 (lookUpTable)hBC->bitLookUp,
753 quantSpectrum,
754 maxValueInSfb,
755 sfbOffset,
756 blockType,
757 noiseNrg,
758 isBook,
759 (syntaxFlags & AC_ER_VCB11)?1:0);
760
761 FDKaacEnc_scfCount(
762 scalefac,
763 maxValueInSfb,
764 sectionData,
765 isScale);
766
767 FDKaacEnc_noiseCount(sectionData,
768 noiseNrg);
769
770 return (sectionData->huffmanBits +
771 sectionData->sideInfoBits +
772 sectionData->scalefacBits +
773 sectionData->noiseNrgBits);
774 }
775
776 INT FDKaacEnc_BCNew(BITCNTR_STATE **phBC
777 ,UCHAR* dynamic_RAM
778 )
779 {
780 BITCNTR_STATE *hBC = GetRam_aacEnc_BitCntrState();
781
782 if (hBC)
783 {
784 *phBC = hBC;
785 hBC->bitLookUp = GetRam_aacEnc_BitLookUp(0,dynamic_RAM);
786 hBC->mergeGainLookUp = GetRam_aacEnc_MergeGainLookUp(0,dynamic_RAM);
787 if (hBC->bitLookUp == 0 ||
788 hBC->mergeGainLookUp == 0)
789 {
790 return 1;
791 }
792 }
793 return (hBC == 0) ? 1 : 0;
794 }
795
796 void FDKaacEnc_BCClose(BITCNTR_STATE **phBC)
797 {
798 if (*phBC!=NULL) {
799
800 FreeRam_aacEnc_BitCntrState(phBC);
801 }
802 }
803
804
805
fdk-aac Piment Noir Debian package repository