mirror of https://github.com/mstorsjo/fdk-aac.git
664 lines
24 KiB
C++
664 lines
24 KiB
C++
/* -----------------------------------------------------------------------------
|
|
Software License for The Fraunhofer FDK AAC Codec Library for Android
|
|
|
|
© Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten
|
|
Forschung e.V. All rights reserved.
|
|
|
|
1. INTRODUCTION
|
|
The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software
|
|
that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding
|
|
scheme for digital audio. This FDK AAC Codec software is intended to be used on
|
|
a wide variety of Android devices.
|
|
|
|
AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient
|
|
general perceptual audio codecs. AAC-ELD is considered the best-performing
|
|
full-bandwidth communications codec by independent studies and is widely
|
|
deployed. AAC has been standardized by ISO and IEC as part of the MPEG
|
|
specifications.
|
|
|
|
Patent licenses for necessary patent claims for the FDK AAC Codec (including
|
|
those of Fraunhofer) may be obtained through Via Licensing
|
|
(www.vialicensing.com) or through the respective patent owners individually for
|
|
the purpose of encoding or decoding bit streams in products that are compliant
|
|
with the ISO/IEC MPEG audio standards. Please note that most manufacturers of
|
|
Android devices already license these patent claims through Via Licensing or
|
|
directly from the patent owners, and therefore FDK AAC Codec software may
|
|
already be covered under those patent licenses when it is used for those
|
|
licensed purposes only.
|
|
|
|
Commercially-licensed AAC software libraries, including floating-point versions
|
|
with enhanced sound quality, are also available from Fraunhofer. Users are
|
|
encouraged to check the Fraunhofer website for additional applications
|
|
information and documentation.
|
|
|
|
2. COPYRIGHT LICENSE
|
|
|
|
Redistribution and use in source and binary forms, with or without modification,
|
|
are permitted without payment of copyright license fees provided that you
|
|
satisfy the following conditions:
|
|
|
|
You must retain the complete text of this software license in redistributions of
|
|
the FDK AAC Codec or your modifications thereto in source code form.
|
|
|
|
You must retain the complete text of this software license in the documentation
|
|
and/or other materials provided with redistributions of the FDK AAC Codec or
|
|
your modifications thereto in binary form. You must make available free of
|
|
charge copies of the complete source code of the FDK AAC Codec and your
|
|
modifications thereto to recipients of copies in binary form.
|
|
|
|
The name of Fraunhofer may not be used to endorse or promote products derived
|
|
from this library without prior written permission.
|
|
|
|
You may not charge copyright license fees for anyone to use, copy or distribute
|
|
the FDK AAC Codec software or your modifications thereto.
|
|
|
|
Your modified versions of the FDK AAC Codec must carry prominent notices stating
|
|
that you changed the software and the date of any change. For modified versions
|
|
of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android"
|
|
must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK
|
|
AAC Codec Library for Android."
|
|
|
|
3. NO PATENT LICENSE
|
|
|
|
NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without
|
|
limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE.
|
|
Fraunhofer provides no warranty of patent non-infringement with respect to this
|
|
software.
|
|
|
|
You may use this FDK AAC Codec software or modifications thereto only for
|
|
purposes that are authorized by appropriate patent licenses.
|
|
|
|
4. DISCLAIMER
|
|
|
|
This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright
|
|
holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
|
|
including but not limited to the implied warranties of merchantability and
|
|
fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
|
CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary,
|
|
or consequential damages, including but not limited to procurement of substitute
|
|
goods or services; loss of use, data, or profits, or business interruption,
|
|
however caused and on any theory of liability, whether in contract, strict
|
|
liability, or tort (including negligence), arising in any way out of the use of
|
|
this software, even if advised of the possibility of such damage.
|
|
|
|
5. CONTACT INFORMATION
|
|
|
|
Fraunhofer Institute for Integrated Circuits IIS
|
|
Attention: Audio and Multimedia Departments - FDK AAC LL
|
|
Am Wolfsmantel 33
|
|
91058 Erlangen, Germany
|
|
|
|
www.iis.fraunhofer.de/amm
|
|
amm-info@iis.fraunhofer.de
|
|
----------------------------------------------------------------------------- */
|
|
|
|
/**************************** AAC encoder library ******************************
|
|
|
|
Author(s): M.Werner
|
|
|
|
Description: Noiseless coder module
|
|
|
|
*******************************************************************************/
|
|
|
|
#include "dyn_bits.h"
|
|
#include "bit_cnt.h"
|
|
#include "psy_const.h"
|
|
#include "aacenc_pns.h"
|
|
#include "aacEnc_ram.h"
|
|
#include "aacEnc_rom.h"
|
|
|
|
typedef INT (*lookUpTable)[CODE_BOOK_ESC_NDX + 1];
|
|
|
|
static INT FDKaacEnc_getSideInfoBits(const SECTION_INFO* const huffsection,
|
|
const SHORT* const sideInfoTab,
|
|
const INT useHCR) {
|
|
INT sideInfoBits;
|
|
|
|
if (useHCR &&
|
|
((huffsection->codeBook == 11) || (huffsection->codeBook >= 16))) {
|
|
sideInfoBits = 5;
|
|
} else {
|
|
sideInfoBits = sideInfoTab[huffsection->sfbCnt];
|
|
}
|
|
|
|
return (sideInfoBits);
|
|
}
|
|
|
|
/* count bits using all possible tables */
|
|
static void FDKaacEnc_buildBitLookUp(
|
|
const SHORT* const quantSpectrum, const INT maxSfb,
|
|
const INT* const sfbOffset, const UINT* const sfbMax,
|
|
INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1],
|
|
SECTION_INFO* const huffsection) {
|
|
INT i, sfbWidth;
|
|
|
|
for (i = 0; i < maxSfb; i++) {
|
|
huffsection[i].sfbCnt = 1;
|
|
huffsection[i].sfbStart = i;
|
|
huffsection[i].sectionBits = INVALID_BITCOUNT;
|
|
huffsection[i].codeBook = -1;
|
|
sfbWidth = sfbOffset[i + 1] - sfbOffset[i];
|
|
FDKaacEnc_bitCount(quantSpectrum + sfbOffset[i], sfbWidth, sfbMax[i],
|
|
bitLookUp[i]);
|
|
}
|
|
}
|
|
|
|
/* essential helper functions */
|
|
static inline INT FDKaacEnc_findBestBook(const INT* const bc, INT* const book,
|
|
const INT useVCB11) {
|
|
INT minBits = INVALID_BITCOUNT, j;
|
|
|
|
int end = CODE_BOOK_ESC_NDX;
|
|
|
|
for (j = 0; j <= end; j++) {
|
|
if (bc[j] < minBits) {
|
|
minBits = bc[j];
|
|
*book = j;
|
|
}
|
|
}
|
|
return (minBits);
|
|
}
|
|
|
|
static inline INT FDKaacEnc_findMinMergeBits(const INT* const bc1,
|
|
const INT* const bc2,
|
|
const INT useVCB11) {
|
|
INT minBits = INVALID_BITCOUNT, j;
|
|
|
|
DWORD_ALIGNED(bc1);
|
|
DWORD_ALIGNED(bc2);
|
|
|
|
for (j = 0; j <= CODE_BOOK_ESC_NDX; j++) {
|
|
minBits = fixMin(minBits, bc1[j] + bc2[j]);
|
|
}
|
|
return (minBits);
|
|
}
|
|
|
|
static inline void FDKaacEnc_mergeBitLookUp(INT* const RESTRICT bc1,
|
|
const INT* const RESTRICT bc2) {
|
|
int j;
|
|
|
|
for (j = 0; j <= CODE_BOOK_ESC_NDX; j++) {
|
|
FDK_ASSERT(INVALID_BITCOUNT == 0x1FFFFFFF);
|
|
bc1[j] = fixMin(bc1[j] + bc2[j], INVALID_BITCOUNT);
|
|
}
|
|
}
|
|
|
|
static inline INT FDKaacEnc_findMaxMerge(const INT* const mergeGainLookUp,
|
|
const SECTION_INFO* const huffsection,
|
|
const INT maxSfb, INT* const maxNdx) {
|
|
INT i, maxMergeGain = 0;
|
|
int lastMaxNdx = 0;
|
|
|
|
for (i = 0; i + huffsection[i].sfbCnt < maxSfb; i += huffsection[i].sfbCnt) {
|
|
if (mergeGainLookUp[i] > maxMergeGain) {
|
|
maxMergeGain = mergeGainLookUp[i];
|
|
lastMaxNdx = i;
|
|
}
|
|
}
|
|
*maxNdx = lastMaxNdx;
|
|
return (maxMergeGain);
|
|
}
|
|
|
|
static inline INT FDKaacEnc_CalcMergeGain(
|
|
const SECTION_INFO* const huffsection,
|
|
const INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1],
|
|
const SHORT* const sideInfoTab, const INT ndx1, const INT ndx2,
|
|
const INT useVCB11) {
|
|
INT MergeGain, MergeBits, SplitBits;
|
|
|
|
MergeBits =
|
|
sideInfoTab[huffsection[ndx1].sfbCnt + huffsection[ndx2].sfbCnt] +
|
|
FDKaacEnc_findMinMergeBits(bitLookUp[ndx1], bitLookUp[ndx2], useVCB11);
|
|
SplitBits =
|
|
huffsection[ndx1].sectionBits +
|
|
huffsection[ndx2].sectionBits; /* Bit amount for splitted huffsections */
|
|
MergeGain = SplitBits - MergeBits;
|
|
|
|
if ((huffsection[ndx1].codeBook == CODE_BOOK_PNS_NO) ||
|
|
(huffsection[ndx2].codeBook == CODE_BOOK_PNS_NO) ||
|
|
(huffsection[ndx1].codeBook == CODE_BOOK_IS_OUT_OF_PHASE_NO) ||
|
|
(huffsection[ndx2].codeBook == CODE_BOOK_IS_OUT_OF_PHASE_NO) ||
|
|
(huffsection[ndx1].codeBook == CODE_BOOK_IS_IN_PHASE_NO) ||
|
|
(huffsection[ndx2].codeBook == CODE_BOOK_IS_IN_PHASE_NO)) {
|
|
MergeGain = -1;
|
|
}
|
|
|
|
return (MergeGain);
|
|
}
|
|
|
|
/* sectioning Stage 0:find minimum codbooks */
|
|
static void FDKaacEnc_gmStage0(
|
|
SECTION_INFO* const RESTRICT huffsection,
|
|
const INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1], const INT maxSfb,
|
|
const INT* const noiseNrg, const INT* const isBook) {
|
|
INT i;
|
|
|
|
for (i = 0; i < maxSfb; i++) {
|
|
/* Side-Info bits will be calculated in Stage 1! */
|
|
if (huffsection[i].sectionBits == INVALID_BITCOUNT) {
|
|
/* intensity and pns codebooks are already allocated in bitcount.c */
|
|
if (noiseNrg[i] != NO_NOISE_PNS) {
|
|
huffsection[i].codeBook = CODE_BOOK_PNS_NO;
|
|
huffsection[i].sectionBits = 0;
|
|
} else if (isBook[i]) {
|
|
huffsection[i].codeBook = isBook[i];
|
|
huffsection[i].sectionBits = 0;
|
|
} else {
|
|
huffsection[i].sectionBits =
|
|
FDKaacEnc_findBestBook(bitLookUp[i], &(huffsection[i].codeBook),
|
|
0); /* useVCB11 must be 0!!! */
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
sectioning Stage 1:merge all connected regions with the same code book and
|
|
calculate side info
|
|
*/
|
|
static void FDKaacEnc_gmStage1(
|
|
SECTION_INFO* const RESTRICT huffsection,
|
|
INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1], const INT maxSfb,
|
|
const SHORT* const sideInfoTab, const INT useVCB11) {
|
|
INT mergeStart = 0, mergeEnd;
|
|
|
|
do {
|
|
for (mergeEnd = mergeStart + 1; mergeEnd < maxSfb; mergeEnd++) {
|
|
if (huffsection[mergeStart].codeBook != huffsection[mergeEnd].codeBook)
|
|
break;
|
|
|
|
/* we can merge. update tables, side info bits will be updated outside of
|
|
* this loop */
|
|
huffsection[mergeStart].sfbCnt++;
|
|
huffsection[mergeStart].sectionBits += huffsection[mergeEnd].sectionBits;
|
|
|
|
/* update bit look up for all code books */
|
|
FDKaacEnc_mergeBitLookUp(bitLookUp[mergeStart], bitLookUp[mergeEnd]);
|
|
}
|
|
|
|
/* add side info info bits */
|
|
huffsection[mergeStart].sectionBits += FDKaacEnc_getSideInfoBits(
|
|
&huffsection[mergeStart], sideInfoTab, useVCB11);
|
|
huffsection[mergeEnd - 1].sfbStart =
|
|
huffsection[mergeStart].sfbStart; /* speed up prev search */
|
|
|
|
mergeStart = mergeEnd;
|
|
|
|
} while (mergeStart < maxSfb);
|
|
}
|
|
|
|
/*
|
|
sectioning Stage 2:greedy merge algorithm, merge connected sections with
|
|
maximum bit gain until no more gain is possible
|
|
*/
|
|
static inline void FDKaacEnc_gmStage2(
|
|
SECTION_INFO* const RESTRICT huffsection,
|
|
INT* const RESTRICT mergeGainLookUp,
|
|
INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1], const INT maxSfb,
|
|
const SHORT* const sideInfoTab, const INT useVCB11) {
|
|
INT i;
|
|
|
|
for (i = 0; i + huffsection[i].sfbCnt < maxSfb; i += huffsection[i].sfbCnt) {
|
|
mergeGainLookUp[i] =
|
|
FDKaacEnc_CalcMergeGain(huffsection, bitLookUp, sideInfoTab, i,
|
|
i + huffsection[i].sfbCnt, useVCB11);
|
|
}
|
|
|
|
while (TRUE) {
|
|
INT maxMergeGain, maxNdx, maxNdxNext, maxNdxLast;
|
|
|
|
maxMergeGain =
|
|
FDKaacEnc_findMaxMerge(mergeGainLookUp, huffsection, maxSfb, &maxNdx);
|
|
|
|
/* exit while loop if no more gain is possible */
|
|
if (maxMergeGain <= 0) break;
|
|
|
|
maxNdxNext = maxNdx + huffsection[maxNdx].sfbCnt;
|
|
|
|
/* merge sections with maximum bit gain */
|
|
huffsection[maxNdx].sfbCnt += huffsection[maxNdxNext].sfbCnt;
|
|
huffsection[maxNdx].sectionBits +=
|
|
huffsection[maxNdxNext].sectionBits - maxMergeGain;
|
|
|
|
/* update bit look up table for merged huffsection */
|
|
FDKaacEnc_mergeBitLookUp(bitLookUp[maxNdx], bitLookUp[maxNdxNext]);
|
|
|
|
/* update mergeLookUpTable */
|
|
if (maxNdx != 0) {
|
|
maxNdxLast = huffsection[maxNdx - 1].sfbStart;
|
|
mergeGainLookUp[maxNdxLast] = FDKaacEnc_CalcMergeGain(
|
|
huffsection, bitLookUp, sideInfoTab, maxNdxLast, maxNdx, useVCB11);
|
|
}
|
|
maxNdxNext = maxNdx + huffsection[maxNdx].sfbCnt;
|
|
|
|
huffsection[maxNdxNext - 1].sfbStart = huffsection[maxNdx].sfbStart;
|
|
|
|
if (maxNdxNext < maxSfb)
|
|
mergeGainLookUp[maxNdx] = FDKaacEnc_CalcMergeGain(
|
|
huffsection, bitLookUp, sideInfoTab, maxNdx, maxNdxNext, useVCB11);
|
|
}
|
|
}
|
|
|
|
/* count bits used by the noiseless coder */
|
|
static void FDKaacEnc_noiselessCounter(
|
|
SECTION_DATA* const RESTRICT sectionData, INT mergeGainLookUp[MAX_SFB_LONG],
|
|
INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1],
|
|
const SHORT* const quantSpectrum, const UINT* const maxValueInSfb,
|
|
const INT* const sfbOffset, const INT blockType, const INT* const noiseNrg,
|
|
const INT* const isBook, const INT useVCB11) {
|
|
INT grpNdx, i;
|
|
const SHORT* sideInfoTab = NULL;
|
|
SECTION_INFO* huffsection;
|
|
|
|
/* use appropriate side info table */
|
|
switch (blockType) {
|
|
case LONG_WINDOW:
|
|
case START_WINDOW:
|
|
case STOP_WINDOW:
|
|
default:
|
|
sideInfoTab = FDKaacEnc_sideInfoTabLong;
|
|
break;
|
|
case SHORT_WINDOW:
|
|
sideInfoTab = FDKaacEnc_sideInfoTabShort;
|
|
break;
|
|
}
|
|
|
|
sectionData->noOfSections = 0;
|
|
sectionData->huffmanBits = 0;
|
|
sectionData->sideInfoBits = 0;
|
|
|
|
if (sectionData->maxSfbPerGroup == 0) return;
|
|
|
|
/* loop trough groups */
|
|
for (grpNdx = 0; grpNdx < sectionData->sfbCnt;
|
|
grpNdx += sectionData->sfbPerGroup) {
|
|
huffsection = sectionData->huffsection + sectionData->noOfSections;
|
|
|
|
/* count bits in this group */
|
|
FDKaacEnc_buildBitLookUp(quantSpectrum, sectionData->maxSfbPerGroup,
|
|
sfbOffset + grpNdx, maxValueInSfb + grpNdx,
|
|
bitLookUp, huffsection);
|
|
|
|
/* 0.Stage :Find minimum Codebooks */
|
|
FDKaacEnc_gmStage0(huffsection, bitLookUp, sectionData->maxSfbPerGroup,
|
|
noiseNrg + grpNdx, isBook + grpNdx);
|
|
|
|
/* 1.Stage :Merge all connected regions with the same code book */
|
|
FDKaacEnc_gmStage1(huffsection, bitLookUp, sectionData->maxSfbPerGroup,
|
|
sideInfoTab, useVCB11);
|
|
|
|
/*
|
|
2.Stage
|
|
greedy merge algorithm, merge connected huffsections with maximum bit
|
|
gain until no more gain is possible
|
|
*/
|
|
|
|
FDKaacEnc_gmStage2(huffsection, mergeGainLookUp, bitLookUp,
|
|
sectionData->maxSfbPerGroup, sideInfoTab, useVCB11);
|
|
|
|
/*
|
|
compress output, calculate total huff and side bits
|
|
since we did not update the actual codebook in stage 2
|
|
to save time, we must set it here for later use in bitenc
|
|
*/
|
|
|
|
for (i = 0; i < sectionData->maxSfbPerGroup; i += huffsection[i].sfbCnt) {
|
|
if ((huffsection[i].codeBook == CODE_BOOK_PNS_NO) ||
|
|
(huffsection[i].codeBook == CODE_BOOK_IS_OUT_OF_PHASE_NO) ||
|
|
(huffsection[i].codeBook == CODE_BOOK_IS_IN_PHASE_NO)) {
|
|
huffsection[i].sectionBits = 0;
|
|
} else {
|
|
/* the sections in the sectionData are now marked with the optimal code
|
|
* book */
|
|
|
|
FDKaacEnc_findBestBook(bitLookUp[i], &(huffsection[i].codeBook),
|
|
useVCB11);
|
|
|
|
sectionData->huffmanBits +=
|
|
huffsection[i].sectionBits -
|
|
FDKaacEnc_getSideInfoBits(&huffsection[i], sideInfoTab, useVCB11);
|
|
}
|
|
|
|
huffsection[i].sfbStart += grpNdx;
|
|
|
|
/* sum up side info bits (section data bits) */
|
|
sectionData->sideInfoBits +=
|
|
FDKaacEnc_getSideInfoBits(&huffsection[i], sideInfoTab, useVCB11);
|
|
sectionData->huffsection[sectionData->noOfSections++] = huffsection[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
|
|
functionname: FDKaacEnc_scfCount
|
|
returns : ---
|
|
description : count bits used by scalefactors.
|
|
|
|
not in all cases if maxValueInSfb[] == 0 we set deltaScf
|
|
to zero. only if the difference of the last and future
|
|
scalefacGain is not greater then CODE_BOOK_SCF_LAV (60).
|
|
|
|
example:
|
|
^
|
|
scalefacGain |
|
|
|
|
|
| last 75
|
|
| |
|
|
| |
|
|
| |
|
|
| | current 50
|
|
| | |
|
|
| | |
|
|
| | |
|
|
| | |
|
|
| | | future 5
|
|
| | | |
|
|
--- ... ---------------------------- ... --------->
|
|
sfb
|
|
|
|
|
|
if maxValueInSfb[] of current is zero because of a
|
|
notfallstrategie, we do not save bits and transmit a
|
|
deltaScf of 25. otherwise the deltaScf between the last
|
|
scalfacGain (75) and the future scalefacGain (5) is 70.
|
|
|
|
********************************************************************************/
|
|
static void FDKaacEnc_scfCount(const INT* const scalefacGain,
|
|
const UINT* const maxValueInSfb,
|
|
SECTION_DATA* const RESTRICT sectionData,
|
|
const INT* const isScale) {
|
|
INT i, j, k, m, n;
|
|
|
|
INT lastValScf = 0;
|
|
INT deltaScf = 0;
|
|
INT found = 0;
|
|
INT scfSkipCounter = 0;
|
|
INT lastValIs = 0;
|
|
|
|
sectionData->scalefacBits = 0;
|
|
|
|
if (scalefacGain == NULL) return;
|
|
|
|
sectionData->firstScf = 0;
|
|
|
|
for (i = 0; i < sectionData->noOfSections; i++) {
|
|
if (sectionData->huffsection[i].codeBook != CODE_BOOK_ZERO_NO) {
|
|
sectionData->firstScf = sectionData->huffsection[i].sfbStart;
|
|
lastValScf = scalefacGain[sectionData->firstScf];
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < sectionData->noOfSections; i++) {
|
|
if ((sectionData->huffsection[i].codeBook ==
|
|
CODE_BOOK_IS_OUT_OF_PHASE_NO) ||
|
|
(sectionData->huffsection[i].codeBook == CODE_BOOK_IS_IN_PHASE_NO)) {
|
|
for (j = sectionData->huffsection[i].sfbStart;
|
|
j < sectionData->huffsection[i].sfbStart +
|
|
sectionData->huffsection[i].sfbCnt;
|
|
j++) {
|
|
INT deltaIs = isScale[j] - lastValIs;
|
|
lastValIs = isScale[j];
|
|
sectionData->scalefacBits +=
|
|
FDKaacEnc_bitCountScalefactorDelta(deltaIs);
|
|
}
|
|
} /* Intensity */
|
|
else if ((sectionData->huffsection[i].codeBook != CODE_BOOK_ZERO_NO) &&
|
|
(sectionData->huffsection[i].codeBook != CODE_BOOK_PNS_NO)) {
|
|
INT tmp = sectionData->huffsection[i].sfbStart +
|
|
sectionData->huffsection[i].sfbCnt;
|
|
for (j = sectionData->huffsection[i].sfbStart; j < tmp; j++) {
|
|
/* check if we can repeat the last value to save bits */
|
|
if (maxValueInSfb[j] == 0) {
|
|
found = 0;
|
|
/* are scalefactors skipped? */
|
|
if (scfSkipCounter == 0) {
|
|
/* end of section */
|
|
if (j == (tmp - 1))
|
|
found = 0; /* search in other sections for maxValueInSfb != 0 */
|
|
else {
|
|
/* search in this section for the next maxValueInSfb[] != 0 */
|
|
for (k = (j + 1); k < tmp; k++) {
|
|
if (maxValueInSfb[k] != 0) {
|
|
found = 1;
|
|
if ((fixp_abs(scalefacGain[k] - lastValScf)) <=
|
|
CODE_BOOK_SCF_LAV)
|
|
deltaScf = 0; /* save bits */
|
|
else {
|
|
/* do not save bits */
|
|
deltaScf = lastValScf - scalefacGain[j];
|
|
lastValScf = scalefacGain[j];
|
|
scfSkipCounter = 0;
|
|
}
|
|
break;
|
|
}
|
|
/* count scalefactor skip */
|
|
scfSkipCounter++;
|
|
}
|
|
}
|
|
|
|
/* search for the next maxValueInSfb[] != 0 in all other sections */
|
|
for (m = (i + 1); (m < sectionData->noOfSections) && (found == 0);
|
|
m++) {
|
|
if ((sectionData->huffsection[m].codeBook != CODE_BOOK_ZERO_NO) &&
|
|
(sectionData->huffsection[m].codeBook != CODE_BOOK_PNS_NO)) {
|
|
INT end = sectionData->huffsection[m].sfbStart +
|
|
sectionData->huffsection[m].sfbCnt;
|
|
for (n = sectionData->huffsection[m].sfbStart; n < end; n++) {
|
|
if (maxValueInSfb[n] != 0) {
|
|
found = 1;
|
|
if (fixp_abs(scalefacGain[n] - lastValScf) <=
|
|
CODE_BOOK_SCF_LAV)
|
|
deltaScf = 0; /* save bits */
|
|
else {
|
|
/* do not save bits */
|
|
deltaScf = lastValScf - scalefacGain[j];
|
|
lastValScf = scalefacGain[j];
|
|
scfSkipCounter = 0;
|
|
}
|
|
break;
|
|
}
|
|
/* count scalefactor skip */
|
|
scfSkipCounter++;
|
|
}
|
|
}
|
|
}
|
|
/* no maxValueInSfb[] != 0 found */
|
|
if (found == 0) {
|
|
deltaScf = 0;
|
|
scfSkipCounter = 0;
|
|
}
|
|
} else {
|
|
/* consider skipped scalefactors */
|
|
deltaScf = 0;
|
|
scfSkipCounter--;
|
|
}
|
|
} else {
|
|
deltaScf = lastValScf - scalefacGain[j];
|
|
lastValScf = scalefacGain[j];
|
|
}
|
|
sectionData->scalefacBits +=
|
|
FDKaacEnc_bitCountScalefactorDelta(deltaScf);
|
|
}
|
|
}
|
|
} /* for (i=0; i<sectionData->noOfSections; i++) */
|
|
}
|
|
|
|
/* count bits used by pns */
|
|
static void FDKaacEnc_noiseCount(SECTION_DATA* const RESTRICT sectionData,
|
|
const INT* const noiseNrg) {
|
|
INT noisePCMFlag = TRUE;
|
|
INT lastValPns = 0, deltaPns;
|
|
int i, j;
|
|
|
|
sectionData->noiseNrgBits = 0;
|
|
|
|
for (i = 0; i < sectionData->noOfSections; i++) {
|
|
if (sectionData->huffsection[i].codeBook == CODE_BOOK_PNS_NO) {
|
|
int sfbStart = sectionData->huffsection[i].sfbStart;
|
|
int sfbEnd = sfbStart + sectionData->huffsection[i].sfbCnt;
|
|
for (j = sfbStart; j < sfbEnd; j++) {
|
|
if (noisePCMFlag) {
|
|
sectionData->noiseNrgBits += PNS_PCM_BITS;
|
|
lastValPns = noiseNrg[j];
|
|
noisePCMFlag = FALSE;
|
|
} else {
|
|
deltaPns = noiseNrg[j] - lastValPns;
|
|
lastValPns = noiseNrg[j];
|
|
sectionData->noiseNrgBits +=
|
|
FDKaacEnc_bitCountScalefactorDelta(deltaPns);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
INT FDKaacEnc_dynBitCount(BITCNTR_STATE* const hBC,
|
|
const SHORT* const quantSpectrum,
|
|
const UINT* const maxValueInSfb,
|
|
const INT* const scalefac, const INT blockType,
|
|
const INT sfbCnt, const INT maxSfbPerGroup,
|
|
const INT sfbPerGroup, const INT* const sfbOffset,
|
|
SECTION_DATA* const RESTRICT sectionData,
|
|
const INT* const noiseNrg, const INT* const isBook,
|
|
const INT* const isScale, const UINT syntaxFlags) {
|
|
sectionData->blockType = blockType;
|
|
sectionData->sfbCnt = sfbCnt;
|
|
sectionData->sfbPerGroup = sfbPerGroup;
|
|
sectionData->noOfGroups = sfbCnt / sfbPerGroup;
|
|
sectionData->maxSfbPerGroup = maxSfbPerGroup;
|
|
|
|
FDKaacEnc_noiselessCounter(sectionData, hBC->mergeGainLookUp,
|
|
(lookUpTable)hBC->bitLookUp, quantSpectrum,
|
|
maxValueInSfb, sfbOffset, blockType, noiseNrg,
|
|
isBook, (syntaxFlags & AC_ER_VCB11) ? 1 : 0);
|
|
|
|
FDKaacEnc_scfCount(scalefac, maxValueInSfb, sectionData, isScale);
|
|
|
|
FDKaacEnc_noiseCount(sectionData, noiseNrg);
|
|
|
|
return (sectionData->huffmanBits + sectionData->sideInfoBits +
|
|
sectionData->scalefacBits + sectionData->noiseNrgBits);
|
|
}
|
|
|
|
INT FDKaacEnc_BCNew(BITCNTR_STATE** phBC, UCHAR* dynamic_RAM) {
|
|
BITCNTR_STATE* hBC = GetRam_aacEnc_BitCntrState();
|
|
|
|
if (hBC) {
|
|
*phBC = hBC;
|
|
hBC->bitLookUp = GetRam_aacEnc_BitLookUp(0, dynamic_RAM);
|
|
hBC->mergeGainLookUp = GetRam_aacEnc_MergeGainLookUp(0, dynamic_RAM);
|
|
if (hBC->bitLookUp == 0 || hBC->mergeGainLookUp == 0) {
|
|
return 1;
|
|
}
|
|
}
|
|
return (hBC == 0) ? 1 : 0;
|
|
}
|
|
|
|
void FDKaacEnc_BCClose(BITCNTR_STATE** phBC) {
|
|
if (*phBC != NULL) {
|
|
FreeRam_aacEnc_BitCntrState(phBC);
|
|
}
|
|
}
|