diff options
Diffstat (limited to 'libAACenc/src/bitenc.cpp')
| -rw-r--r-- | libAACenc/src/bitenc.cpp | 1508 |
1 files changed, 0 insertions, 1508 deletions
diff --git a/libAACenc/src/bitenc.cpp b/libAACenc/src/bitenc.cpp deleted file mode 100644 index 4552457..0000000 --- a/libAACenc/src/bitenc.cpp +++ /dev/null @@ -1,1508 +0,0 @@ - -/* ----------------------------------------------------------------------------------------------------------- -Software License for The Fraunhofer FDK AAC Codec Library for Android - -© Copyright 1995 - 2013 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 ------------------------------------------------------------------------------------------------------------ */ - - /******************************** MPEG Audio Encoder ************************** - - Initial author: M. Werner - contents/description: Bitstream encoder - -******************************************************************************/ -#include <stdio.h> -#include "bitenc.h" -#include "bit_cnt.h" -#include "dyn_bits.h" -#include "qc_data.h" -#include "interface.h" -#include "aacEnc_ram.h" - - -#include "tpenc_lib.h" - -#include "FDK_tools_rom.h" /* needed for the bitstream syntax tables */ - -static const int globalGainOffset = 100; -static const int icsReservedBit = 0; -static const int noiseOffset = 90; - -/***************************************************************************** - - functionname: FDKaacEnc_encodeSpectralData - description: encode spectral data - returns: the number of written bits - input: - output: - -*****************************************************************************/ -static INT FDKaacEnc_encodeSpectralData(INT *sfbOffset, - SECTION_DATA *sectionData, - SHORT *quantSpectrum, - HANDLE_FDK_BITSTREAM hBitStream) -{ - INT i,sfb; - INT dbgVal = FDKgetValidBits(hBitStream); - - for(i=0;i<sectionData->noOfSections;i++) - { - if(sectionData->huffsection[i].codeBook != CODE_BOOK_PNS_NO) - { - /* huffencode spectral data for this huffsection */ - INT tmp = sectionData->huffsection[i].sfbStart+sectionData->huffsection[i].sfbCnt; - for(sfb=sectionData->huffsection[i].sfbStart; sfb<tmp; sfb++) - { - FDKaacEnc_codeValues(quantSpectrum+sfbOffset[sfb], - sfbOffset[sfb+1]-sfbOffset[sfb], - sectionData->huffsection[i].codeBook, - hBitStream); - } - } - } - return(FDKgetValidBits(hBitStream)-dbgVal); -} - -/***************************************************************************** - - functionname:FDKaacEnc_encodeGlobalGain - description: encodes Global Gain (common scale factor) - returns: the number of static bits - input: - output: - -*****************************************************************************/ -static INT FDKaacEnc_encodeGlobalGain(INT globalGain, - INT scalefac, - HANDLE_FDK_BITSTREAM hBitStream, - INT mdctScale) -{ - if (hBitStream != NULL) { - FDKwriteBits(hBitStream,globalGain - scalefac + globalGainOffset-4*(LOG_NORM_PCM-mdctScale),8); - } - return (8); -} - - -/***************************************************************************** - - functionname:FDKaacEnc_encodeIcsInfo - description: encodes Ics Info - returns: the number of static bits - input: - output: - -*****************************************************************************/ - -static INT FDKaacEnc_encodeIcsInfo(INT blockType, - INT windowShape, - INT groupingMask, - INT maxSfbPerGroup, - HANDLE_FDK_BITSTREAM hBitStream, - UINT syntaxFlags) -{ - INT statBits; - - if (blockType == SHORT_WINDOW) { - statBits = 8 + TRANS_FAC - 1; - } else { - if (syntaxFlags & AC_ELD) { - statBits = 6; - } else - { - statBits = (!(syntaxFlags & AC_SCALABLE)) ? 11 : 10; - } - } - - if (hBitStream != NULL) { - - if (!(syntaxFlags & AC_ELD)){ - FDKwriteBits(hBitStream,icsReservedBit,1); - FDKwriteBits(hBitStream,blockType,2); - FDKwriteBits(hBitStream, (windowShape == LOL_WINDOW) ? KBD_WINDOW : windowShape,1); - } - - switch(blockType){ - case LONG_WINDOW: - case START_WINDOW: - case STOP_WINDOW: - FDKwriteBits(hBitStream,maxSfbPerGroup,6); - - if (!(syntaxFlags & (AC_SCALABLE|AC_ELD)) ) { /* If not scalable syntax then ... */ - /* No predictor data present */ - FDKwriteBits(hBitStream, 0, 1); - } - break; - - case SHORT_WINDOW: - FDKwriteBits(hBitStream,maxSfbPerGroup,4); - - /* Write grouping bits */ - FDKwriteBits(hBitStream,groupingMask,TRANS_FAC-1); - break; - } - } - - return (statBits); -} - -/***************************************************************************** - - functionname: FDKaacEnc_encodeSectionData - description: encode section data (common Huffman codebooks for adjacent - SFB's) - returns: none - input: - output: - -*****************************************************************************/ -static INT FDKaacEnc_encodeSectionData(SECTION_DATA *sectionData, - HANDLE_FDK_BITSTREAM hBitStream, - UINT useVCB11) -{ - if (hBitStream != NULL) { - INT sectEscapeVal=0,sectLenBits=0; - INT sectLen; - INT i; - INT dbgVal=FDKgetValidBits(hBitStream); - INT sectCbBits = 4; - - switch(sectionData->blockType) - { - case LONG_WINDOW: - case START_WINDOW: - case STOP_WINDOW: - sectEscapeVal = SECT_ESC_VAL_LONG; - sectLenBits = SECT_BITS_LONG; - break; - - case SHORT_WINDOW: - sectEscapeVal = SECT_ESC_VAL_SHORT; - sectLenBits = SECT_BITS_SHORT; - break; - } - - for(i=0;i<sectionData->noOfSections;i++) - { - INT codeBook = sectionData->huffsection[i].codeBook; - - FDKwriteBits(hBitStream,codeBook,sectCbBits); - - { - sectLen = sectionData->huffsection[i].sfbCnt; - - while(sectLen >= sectEscapeVal) - { - FDKwriteBits(hBitStream,sectEscapeVal,sectLenBits); - sectLen-=sectEscapeVal; - } - FDKwriteBits(hBitStream,sectLen,sectLenBits); - } - } - return(FDKgetValidBits(hBitStream)-dbgVal); - } - return (0); -} - -/***************************************************************************** - - functionname: FDKaacEnc_encodeScaleFactorData - description: encode DPCM coded scale factors - returns: none - input: - output: - -*****************************************************************************/ -static INT FDKaacEnc_encodeScaleFactorData(UINT *maxValueInSfb, - SECTION_DATA *sectionData, - INT *scalefac, - HANDLE_FDK_BITSTREAM hBitStream, - INT *RESTRICT noiseNrg, - const INT *isScale, - INT globalGain) -{ - if (hBitStream != NULL) { - INT i,j,lastValScf,deltaScf; - INT deltaPns; - INT lastValPns = 0; - INT noisePCMFlag = TRUE; - INT lastValIs; - - INT dbgVal = FDKgetValidBits(hBitStream); - - lastValScf=scalefac[sectionData->firstScf]; - lastValPns = globalGain-scalefac[sectionData->firstScf]+globalGainOffset-4*LOG_NORM_PCM-noiseOffset; - lastValIs = 0; - - for(i=0; i<sectionData->noOfSections; i++){ - if (sectionData->huffsection[i].codeBook != CODE_BOOK_ZERO_NO) { - - if ((sectionData->huffsection[i].codeBook == CODE_BOOK_IS_OUT_OF_PHASE_NO) || - (sectionData->huffsection[i].codeBook == CODE_BOOK_IS_IN_PHASE_NO)) - { - INT sfbStart = sectionData->huffsection[i].sfbStart; - INT tmp = sfbStart + sectionData->huffsection[i].sfbCnt; - for(j=sfbStart; j<tmp; j++) { - INT deltaIs = isScale[j]-lastValIs; - lastValIs = isScale[j]; - if(FDKaacEnc_codeScalefactorDelta(deltaIs,hBitStream)) { - return(1); - } - } /* sfb */ - } - else if(sectionData->huffsection[i].codeBook == CODE_BOOK_PNS_NO) { - INT sfbStart = sectionData->huffsection[i].sfbStart; - INT tmp = sfbStart + sectionData->huffsection[i].sfbCnt; - for(j=sfbStart; j<tmp; j++) { - deltaPns = noiseNrg[j]-lastValPns; - lastValPns = noiseNrg[j]; - - if(noisePCMFlag){ - FDKwriteBits(hBitStream,deltaPns+(1<<(PNS_PCM_BITS-1)),PNS_PCM_BITS); - noisePCMFlag = FALSE; - } - else { - if(FDKaacEnc_codeScalefactorDelta(deltaPns,hBitStream)) { - return(1); - } - } - } /* sfb */ - } - else { - 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) - deltaScf = 0; - else{ - deltaScf = -(scalefac[j]-lastValScf); - lastValScf = scalefac[j]; - } - if(FDKaacEnc_codeScalefactorDelta(deltaScf,hBitStream)){ - return(1); - } - } /* sfb */ - } /* code scalefactor */ - } /* sectionData->huffsection[i].codeBook != CODE_BOOK_ZERO_NO */ - } /* section loop */ - - return(FDKgetValidBits(hBitStream)-dbgVal); - } /* if (hBitStream != NULL) */ - - return (0); -} - -/***************************************************************************** - - functionname:encodeMsInfo - description: encodes MS-Stereo Info - returns: the number of static bits - input: - output: - -*****************************************************************************/ -static INT FDKaacEnc_encodeMSInfo(INT sfbCnt, - INT grpSfb, - INT maxSfb, - INT msDigest, - INT *jsFlags, - HANDLE_FDK_BITSTREAM hBitStream) -{ - INT sfb, sfbOff, msBits = 0; - - if (hBitStream != NULL) - { - switch(msDigest) - { - case MS_NONE: - FDKwriteBits(hBitStream,SI_MS_MASK_NONE,2); - msBits += 2; - break; - - case MS_ALL: - FDKwriteBits(hBitStream,SI_MS_MASK_ALL,2); - msBits += 2; - break; - - case MS_SOME: - FDKwriteBits(hBitStream,SI_MS_MASK_SOME,2); - msBits += 2; - for(sfbOff = 0; sfbOff < sfbCnt; sfbOff+=grpSfb) - { - for(sfb=0; sfb<maxSfb; sfb++) - { - if(jsFlags[sfbOff+sfb] & MS_ON){ - FDKwriteBits(hBitStream,1,1); - } - else{ - FDKwriteBits(hBitStream,0,1); - } - msBits += 1; - } - } - break; - } - } - else { - msBits += 2; - if (msDigest == MS_SOME) { - for(sfbOff = 0; sfbOff < sfbCnt; sfbOff+=grpSfb) { - for(sfb=0; sfb<maxSfb; sfb++) { - msBits += 1; - } - } - } - } - return (msBits); -} - -/***************************************************************************** - - functionname: FDKaacEnc_encodeTnsDataPresent - description: encode TNS data (filter order, coeffs, ..) - returns: the number of static bits - input: - output: - -*****************************************************************************/ -static INT FDKaacEnc_encodeTnsDataPresent(TNS_INFO *tnsInfo, - INT blockType, - HANDLE_FDK_BITSTREAM hBitStream) -{ - if ( (hBitStream!=NULL) && (tnsInfo!=NULL) ) - { - INT i, tnsPresent = 0; - INT numOfWindows = (blockType==SHORT_WINDOW?TRANS_FAC:1); - - for (i=0; i<numOfWindows; i++) { - if (tnsInfo->numOfFilters[i]!=0) { - tnsPresent=1; - break; - } - } - - if (tnsPresent==0) { - FDKwriteBits(hBitStream,0,1); - } else { - FDKwriteBits(hBitStream,1,1); - } - } - return (1); -} - -/***************************************************************************** - - functionname: FDKaacEnc_encodeTnsData - description: encode TNS data (filter order, coeffs, ..) - returns: the number of static bits - input: - output: - -*****************************************************************************/ -static INT FDKaacEnc_encodeTnsData(TNS_INFO *tnsInfo, - INT blockType, - HANDLE_FDK_BITSTREAM hBitStream) -{ - INT tnsBits = 0; - - if (tnsInfo!=NULL) { - - INT i,j,k; - INT tnsPresent = 0; - INT coefBits; - INT numOfWindows=(blockType==SHORT_WINDOW?TRANS_FAC:1); - - for (i=0; i<numOfWindows; i++) { - if (tnsInfo->numOfFilters[i]!=0) { - tnsPresent=1; - } - } - - if (hBitStream != NULL) - { - if (tnsPresent==1) { /* there is data to be written*/ - for (i=0; i<numOfWindows; i++) { - FDKwriteBits(hBitStream,tnsInfo->numOfFilters[i],(blockType==SHORT_WINDOW?1:2)); - tnsBits += (blockType==SHORT_WINDOW?1:2); - if (tnsInfo->numOfFilters[i]) { - FDKwriteBits(hBitStream,(tnsInfo->coefRes[i]==4?1:0),1); - tnsBits += 1; - } - for (j=0; j<tnsInfo->numOfFilters[i]; j++) { - FDKwriteBits(hBitStream,tnsInfo->length[i][j],(blockType==SHORT_WINDOW?4:6)); - tnsBits += (blockType==SHORT_WINDOW?4:6); - FDK_ASSERT(tnsInfo->order[i][j] <= 12); - FDKwriteBits(hBitStream,tnsInfo->order[i][j],(blockType==SHORT_WINDOW?3:5)); - tnsBits += (blockType==SHORT_WINDOW?3:5); - if (tnsInfo->order[i][j]){ - FDKwriteBits(hBitStream,tnsInfo->direction[i][j],1); - tnsBits +=1; /*direction*/ - if(tnsInfo->coefRes[i] == 4) { - coefBits = 3; - for(k=0; k<tnsInfo->order[i][j]; k++) { - if (tnsInfo->coef[i][j][k]> 3 || - tnsInfo->coef[i][j][k]< -4) { - coefBits = 4; - break; - } - } - } else { - coefBits = 2; - for(k=0; k<tnsInfo->order[i][j]; k++) { - if ( tnsInfo->coef[i][j][k]> 1 - || tnsInfo->coef[i][j][k]< -2) { - coefBits = 3; - break; - } - } - } - FDKwriteBits(hBitStream,-(coefBits - tnsInfo->coefRes[i]),1); /*coef_compres*/ - tnsBits +=1; /*coef_compression */ - for (k=0; k<tnsInfo->order[i][j]; k++ ) { - static const INT rmask[] = {0,1,3,7,15}; - FDKwriteBits(hBitStream,tnsInfo->coef[i][j][k] & rmask[coefBits],coefBits); - tnsBits += coefBits; - } - } - } - } - } - } - else { - if (tnsPresent != 0) { - for (i=0; i<numOfWindows; i++) { - tnsBits += (blockType==SHORT_WINDOW?1:2); - if (tnsInfo->numOfFilters[i]) { - tnsBits += 1; - for (j=0; j<tnsInfo->numOfFilters[i]; j++) { - tnsBits += (blockType==SHORT_WINDOW?4:6); - tnsBits += (blockType==SHORT_WINDOW?3:5); - if (tnsInfo->order[i][j]) { - tnsBits +=1; /*direction*/ - tnsBits +=1; /*coef_compression */ - if (tnsInfo->coefRes[i] == 4) { - coefBits=3; - for (k=0; k<tnsInfo->order[i][j]; k++) { - if (tnsInfo->coef[i][j][k]> 3 || tnsInfo->coef[i][j][k]< -4) { - coefBits = 4; - break; - } - } - } - else { - coefBits = 2; - for (k=0; k<tnsInfo->order[i][j]; k++) { - if (tnsInfo->coef[i][j][k]> 1 || tnsInfo->coef[i][j][k]< -2) { - coefBits = 3; - break; - } - } - } - for (k=0; k<tnsInfo->order[i][j]; k++) { - tnsBits += coefBits; - } - } - } - } - } - } - } - } /* (tnsInfo!=NULL) */ - - return (tnsBits); -} - -/***************************************************************************** - - functionname: FDKaacEnc_encodeGainControlData - description: unsupported - returns: none - input: - output: - -*****************************************************************************/ -static INT FDKaacEnc_encodeGainControlData(HANDLE_FDK_BITSTREAM hBitStream) -{ - if (hBitStream != NULL) { - FDKwriteBits(hBitStream,0,1); - } - return (1); -} - -/***************************************************************************** - - functionname: FDKaacEnc_encodePulseData - description: not supported yet (dummy) - returns: none - input: - output: - -*****************************************************************************/ -static INT FDKaacEnc_encodePulseData(HANDLE_FDK_BITSTREAM hBitStream) -{ - if (hBitStream != NULL) { - FDKwriteBits(hBitStream,0,1); - } - return (1); -} - - -/***************************************************************************** - - functionname: FDKaacEnc_writeExtensionPayload - description: write extension payload to bitstream - returns: number of written bits - input: - output: - -*****************************************************************************/ -static INT FDKaacEnc_writeExtensionPayload( HANDLE_FDK_BITSTREAM hBitStream, - EXT_PAYLOAD_TYPE extPayloadType, - const UCHAR *extPayloadData, - INT extPayloadBits - ) -{ - #define EXT_TYPE_BITS ( 4 ) - #define DATA_EL_VERSION_BITS ( 4 ) - #define FILL_NIBBLE_BITS ( 4 ) - - INT extBitsUsed = 0; - //fprintf(stderr, "FDKaacEnc_writeExtensionPayload() extPayloadType=%d\n", extPayloadType); - if (extPayloadBits >= EXT_TYPE_BITS) - { - UCHAR fillByte = 0x00; /* for EXT_FIL and EXT_FILL_DATA */ - - if (hBitStream != NULL) { - FDKwriteBits(hBitStream, extPayloadType, EXT_TYPE_BITS); - } - extBitsUsed += EXT_TYPE_BITS; - - switch (extPayloadType) { - case EXT_DYNAMIC_RANGE: - /* case EXT_SAC_DATA: */ - case EXT_SBR_DATA: - case EXT_SBR_DATA_CRC: - if (hBitStream != NULL) { - int i, writeBits = extPayloadBits; - for (i=0; writeBits >= 8; i++) { - FDKwriteBits(hBitStream, extPayloadData[i], 8); - writeBits -= 8; - } - if (writeBits > 0) { - FDKwriteBits(hBitStream, extPayloadData[i]>>(8-writeBits), writeBits); - } - } - extBitsUsed += extPayloadBits; - break; - - case EXT_DATA_ELEMENT: - { - INT dataElementLength = (extPayloadBits+7)>>3; - INT cnt = dataElementLength; - int loopCounter = 1; - - while (dataElementLength >= 255) { - loopCounter++; - dataElementLength -= 255; - } - - if (hBitStream != NULL) { - int i; - FDKwriteBits(hBitStream, 0x00, DATA_EL_VERSION_BITS); /* data_element_version = ANC_DATA */ - - for (i=1; i<loopCounter; i++) { - FDKwriteBits(hBitStream, 255, 8); - } - FDKwriteBits(hBitStream, dataElementLength, 8); - - for (i=0; i<cnt; i++) { - FDKwriteBits(hBitStream, extPayloadData[i], 8); - } - } - extBitsUsed += DATA_EL_VERSION_BITS + (loopCounter*8) + (cnt*8); - } - break; - - case EXT_FILL_DATA: - fillByte = 0xA5; - case EXT_FIL: - default: - if (hBitStream != NULL) { - int writeBits = extPayloadBits; - FDKwriteBits(hBitStream, 0x00, FILL_NIBBLE_BITS); - writeBits -= 8; /* acount for the extension type and the fill nibble */ - while (writeBits >= 8) { - FDKwriteBits(hBitStream, fillByte, 8); - writeBits -= 8; - } - } - extBitsUsed += FILL_NIBBLE_BITS + (extPayloadBits & ~0x7) - 8; - break; - } - } - - return (extBitsUsed); -} - - -/***************************************************************************** - - functionname: FDKaacEnc_writeDataStreamElement - description: write data stream elements like ancillary data ... - returns: the amount of used bits - input: - output: - -******************************************************************************/ -static INT FDKaacEnc_writeDataStreamElement( HANDLE_TRANSPORTENC hTpEnc, - INT elementInstanceTag, - INT dataPayloadBytes, - UCHAR *dataBuffer, - UINT alignAnchor ) -{ - #define DATA_BYTE_ALIGN_FLAG ( 0 ) - - #define EL_INSTANCE_TAG_BITS ( 4 ) - #define DATA_BYTE_ALIGN_FLAG_BITS ( 1 ) - #define DATA_LEN_COUNT_BITS ( 8 ) - #define DATA_LEN_ESC_COUNT_BITS ( 8 ) - - #define MAX_DATA_ALIGN_BITS ( 7 ) - #define MAX_DSE_DATA_BYTES ( 510 ) - - INT dseBitsUsed = 0; - //fprintf(stderr, "FDKaacEnc_writeDataStreamElement() dataPayloadBytes=%d\n", dataPayloadBytes); - while (dataPayloadBytes > 0) - { - int esc_count = -1; - int cnt = 0; - INT crcReg = -1; - - dseBitsUsed += EL_ID_BITS + EL_INSTANCE_TAG_BITS - + DATA_BYTE_ALIGN_FLAG_BITS + DATA_LEN_COUNT_BITS; - - if (DATA_BYTE_ALIGN_FLAG) { - dseBitsUsed += MAX_DATA_ALIGN_BITS; - } - - cnt = fixMin(MAX_DSE_DATA_BYTES, dataPayloadBytes); - if ( cnt >= 255 ) { - esc_count = cnt - 255; - dseBitsUsed += DATA_LEN_ESC_COUNT_BITS; - } - - dataPayloadBytes -= cnt; - dseBitsUsed += cnt * 8; - - if (hTpEnc != NULL) { - HANDLE_FDK_BITSTREAM hBitStream = transportEnc_GetBitstream(hTpEnc); - int i; - - FDKwriteBits(hBitStream, ID_DSE, EL_ID_BITS); - - crcReg = transportEnc_CrcStartReg(hTpEnc, 0); - - FDKwriteBits(hBitStream, elementInstanceTag, EL_INSTANCE_TAG_BITS); - FDKwriteBits(hBitStream, DATA_BYTE_ALIGN_FLAG, DATA_BYTE_ALIGN_FLAG_BITS); - - /* write length field(s) */ - if ( esc_count >= 0 ) { - FDKwriteBits(hBitStream, 255, DATA_LEN_COUNT_BITS); - FDKwriteBits(hBitStream, esc_count, DATA_LEN_ESC_COUNT_BITS); - } else { - FDKwriteBits(hBitStream, cnt, DATA_LEN_COUNT_BITS); - } - - if (DATA_BYTE_ALIGN_FLAG) { - INT tmp = (INT)FDKgetValidBits(hBitStream); - FDKbyteAlign(hBitStream, alignAnchor); - /* count actual bits */ - dseBitsUsed += (INT)FDKgetValidBits(hBitStream) - tmp - MAX_DATA_ALIGN_BITS; - } - - /* write payload */ - for (i=0; i<cnt; i++) { - FDKwriteBits(hBitStream, dataBuffer[i], 8); - } - transportEnc_CrcEndReg(hTpEnc, crcReg); - } - } - - return (dseBitsUsed); -} - - -/***************************************************************************** - - functionname: FDKaacEnc_writeExtensionData - description: write extension payload to bitstream - returns: number of written bits - input: - output: - -*****************************************************************************/ -INT FDKaacEnc_writeExtensionData( HANDLE_TRANSPORTENC hTpEnc, - QC_OUT_EXTENSION *pExtension, - INT elInstanceTag, /* for DSE only */ - UINT alignAnchor, /* for DSE only */ - UINT syntaxFlags, - AUDIO_OBJECT_TYPE aot, - SCHAR epConfig - ) -{ - #define FILL_EL_COUNT_BITS ( 4 ) - #define FILL_EL_ESC_COUNT_BITS ( 8 ) - #define MAX_FILL_DATA_BYTES ( 269 ) - - HANDLE_FDK_BITSTREAM hBitStream = NULL; - INT payloadBits = pExtension->nPayloadBits; - INT extBitsUsed = 0; - - if (hTpEnc != NULL) { - hBitStream = transportEnc_GetBitstream(hTpEnc); - } - - //fprintf(stderr, "FDKaacEnc_writeExtensionData() pExtension->type=%d\n", pExtension->type); - if (syntaxFlags & (AC_SCALABLE|AC_ER)) - { - if ( syntaxFlags & AC_DRM ) - { /* CAUTION: The caller has to assure that fill - data is written before the SBR payload. */ - UCHAR *extPayloadData = pExtension->pPayload; - - switch (pExtension->type) - { - case EXT_SBR_DATA: - case EXT_SBR_DATA_CRC: - /* SBR payload is written in reverse */ - if (hBitStream != NULL) { - int i, writeBits = payloadBits; - - FDKpushFor(hBitStream, payloadBits-1); /* Does a cache sync internally */ - - for (i=0; writeBits >= 8; i++) { - FDKwriteBitsBwd(hBitStream, extPayloadData[i], 8); - writeBits -= 8; - } - if (writeBits > 0) { - FDKwriteBitsBwd(hBitStream, extPayloadData[i]>>(8-writeBits), writeBits); - } - - FDKsyncCacheBwd (hBitStream); - FDKpushFor (hBitStream, payloadBits+1); - } - extBitsUsed += payloadBits; - break; - - case EXT_FILL_DATA: - case EXT_FIL: - default: - if (hBitStream != NULL) { - int writeBits = payloadBits; - while (writeBits >= 8) { - FDKwriteBits(hBitStream, 0x00, 8); - writeBits -= 8; - } - FDKwriteBits(hBitStream, 0x00, writeBits); - } - extBitsUsed += payloadBits; - break; - } - } - else { - if ( (syntaxFlags & AC_ELD) && ((pExtension->type==EXT_SBR_DATA) || (pExtension->type==EXT_SBR_DATA_CRC)) ) { - - if (hBitStream != NULL) { - int i, writeBits = payloadBits; - UCHAR *extPayloadData = pExtension->pPayload; - - for (i=0; writeBits >= 8; i++) { - FDKwriteBits(hBitStream, extPayloadData[i], 8); - writeBits -= 8; - } - if (writeBits > 0) { - FDKwriteBits(hBitStream, extPayloadData[i]>>(8-writeBits), writeBits); - } - } - extBitsUsed += payloadBits; - } - else - { - /* ER or scalable syntax -> write extension en bloc */ - extBitsUsed += FDKaacEnc_writeExtensionPayload( hBitStream, - pExtension->type, - pExtension->pPayload, - payloadBits ); - } - } - } - else { - /* We have normal GA bitstream payload (AOT 2,5,29) so pack - the data into a fill elements or DSEs */ - - if ( pExtension->type == EXT_DATA_ELEMENT ) - { - extBitsUsed += FDKaacEnc_writeDataStreamElement( hTpEnc, - elInstanceTag, - pExtension->nPayloadBits>>3, - pExtension->pPayload, - alignAnchor ); - } - else { - while (payloadBits >= (EL_ID_BITS + FILL_EL_COUNT_BITS)) { - INT cnt, esc_count=-1, alignBits=7; - - if ( (pExtension->type == EXT_FILL_DATA) || (pExtension->type == EXT_FIL) ) - { - payloadBits -= EL_ID_BITS + FILL_EL_COUNT_BITS; - if (payloadBits >= 15*8) { - payloadBits -= FILL_EL_ESC_COUNT_BITS; - esc_count = 0; /* write esc_count even if cnt becomes smaller 15 */ - } - alignBits = 0; - } - - cnt = fixMin(MAX_FILL_DATA_BYTES, (payloadBits+alignBits)>>3); - - if (cnt >= 15) { - esc_count = cnt - 15 + 1; - } - - if (hBitStream != NULL) { - /* write bitstream */ - FDKwriteBits(hBitStream, ID_FIL, EL_ID_BITS); - if (esc_count >= 0) { - FDKwriteBits(hBitStream, 15, FILL_EL_COUNT_BITS); - FDKwriteBits(hBitStream, esc_count, FILL_EL_ESC_COUNT_BITS); - } else { - FDKwriteBits(hBitStream, cnt, FILL_EL_COUNT_BITS); - } - } - - extBitsUsed += EL_ID_BITS + FILL_EL_COUNT_BITS + ((esc_count>=0) ? FILL_EL_ESC_COUNT_BITS : 0); - - cnt = fixMin(cnt*8, payloadBits); /* convert back to bits */ - extBitsUsed += FDKaacEnc_writeExtensionPayload( hBitStream, - pExtension->type, - pExtension->pPayload, - cnt ); - payloadBits -= cnt; - } - } - } - - return (extBitsUsed); -} - - -/***************************************************************************** - - functionname: FDKaacEnc_ByteAlignment - description: - returns: - input: - output: - -*****************************************************************************/ -static void FDKaacEnc_ByteAlignment(HANDLE_FDK_BITSTREAM hBitStream, int alignBits) -{ - FDKwriteBits(hBitStream, 0, alignBits); -} - -AAC_ENCODER_ERROR FDKaacEnc_ChannelElementWrite( HANDLE_TRANSPORTENC hTpEnc, - ELEMENT_INFO *pElInfo, - QC_OUT_CHANNEL *qcOutChannel[(2)], - PSY_OUT_ELEMENT *psyOutElement, - PSY_OUT_CHANNEL *psyOutChannel[(2)], - UINT syntaxFlags, - AUDIO_OBJECT_TYPE aot, - SCHAR epConfig, - INT *pBitDemand, - UCHAR minCnt - ) -{ - AAC_ENCODER_ERROR error = AAC_ENC_OK; - HANDLE_FDK_BITSTREAM hBitStream = NULL; - INT bitDemand = 0; - const element_list_t *list; - int i, ch, decision_bit; - INT crcReg1 = -1, crcReg2 = -1; - UCHAR numberOfChannels; - - if (hTpEnc != NULL) { - /* Get bitstream handle */ - hBitStream = transportEnc_GetBitstream(hTpEnc); - } - - if ( (pElInfo->elType==ID_SCE) || (pElInfo->elType==ID_LFE) ) { - numberOfChannels = 1; - } else { - numberOfChannels = 2; - } - - /* Get channel element sequence table */ - list = getBitstreamElementList(aot, epConfig, numberOfChannels, 0); - if (list == NULL) { - error = AAC_ENC_UNSUPPORTED_AOT; - goto bail; - } - - if (!(syntaxFlags & (AC_SCALABLE|AC_ER))) { - if (hBitStream != NULL) { - FDKwriteBits(hBitStream, pElInfo->elType, EL_ID_BITS); - } - bitDemand += EL_ID_BITS; - } - - /* Iterate through sequence table */ - i = 0; - ch = 0; - decision_bit = 0; - do { - /* some tmp values */ - SECTION_DATA *pChSectionData = NULL; - INT *pChScf = NULL; - UINT *pChMaxValueInSfb = NULL; - TNS_INFO *pTnsInfo = NULL; - INT chGlobalGain = 0; - INT chBlockType = 0; - INT chMaxSfbPerGrp = 0; - INT chSfbPerGrp = 0; - INT chSfbCnt = 0; - INT chFirstScf = 0; - - if (minCnt==0) { - if ( qcOutChannel!=NULL ) { - pChSectionData = &(qcOutChannel[ch]->sectionData); - pChScf = qcOutChannel[ch]->scf; - chGlobalGain = qcOutChannel[ch]->globalGain; - pChMaxValueInSfb = qcOutChannel[ch]->maxValueInSfb; - chBlockType = pChSectionData->blockType; - chMaxSfbPerGrp = pChSectionData->maxSfbPerGroup; - chSfbPerGrp = pChSectionData->sfbPerGroup; - chSfbCnt = pChSectionData->sfbCnt; - chFirstScf = pChScf[pChSectionData->firstScf]; - } - else { - /* get values from PSY */ - chSfbCnt = psyOutChannel[ch]->sfbCnt; - chSfbPerGrp = psyOutChannel[ch]->sfbPerGroup; - chMaxSfbPerGrp = psyOutChannel[ch]->maxSfbPerGroup; - } - pTnsInfo = &psyOutChannel[ch]->tnsInfo; - } /* minCnt==0 */ - - if ( qcOutChannel==NULL ) { - chBlockType = psyOutChannel[ch]->lastWindowSequence; - } - - switch (list->id[i]) - { - case element_instance_tag: - /* Write element instance tag */ - if (hBitStream != NULL) { - FDKwriteBits(hBitStream, pElInfo->instanceTag, 4); - } - bitDemand += 4; - break; - - case common_window: - /* Write common window flag */ - decision_bit = psyOutElement->commonWindow; - if (hBitStream != NULL) { - FDKwriteBits(hBitStream, psyOutElement->commonWindow, 1); - } - bitDemand += 1; - break; - - case ics_info: - /* Write individual channel info */ - bitDemand += FDKaacEnc_encodeIcsInfo( chBlockType, - psyOutChannel[ch]->windowShape, - psyOutChannel[ch]->groupingMask, - chMaxSfbPerGrp, - hBitStream, - syntaxFlags); - break; - - case ltp_data_present: - /* Write LTP data present flag */ - if (hBitStream != NULL) { - FDKwriteBits(hBitStream, 0, 1); - } - bitDemand += 1; - break; - - case ltp_data: - /* Predictor data not supported. - Nothing to do here. */ - break; - - case ms: - /* Write MS info */ - bitDemand += FDKaacEnc_encodeMSInfo( chSfbCnt, - chSfbPerGrp, - chMaxSfbPerGrp, - (minCnt==0) ? psyOutElement->toolsInfo.msDigest : MS_NONE, - psyOutElement->toolsInfo.msMask, - hBitStream); - break; - - case global_gain: - bitDemand += FDKaacEnc_encodeGlobalGain( chGlobalGain, - chFirstScf, - hBitStream, - psyOutChannel[ch]->mdctScale ); - break; - - case section_data: - { - INT siBits = FDKaacEnc_encodeSectionData(pChSectionData, hBitStream, (syntaxFlags & AC_ER_VCB11)?1:0); - if (hBitStream != NULL) { - if (siBits != qcOutChannel[ch]->sectionData.sideInfoBits) { - error = AAC_ENC_WRITE_SEC_ERROR; - } - } - bitDemand += siBits; - } - break; - - case scale_factor_data: - { - INT sfDataBits = FDKaacEnc_encodeScaleFactorData( pChMaxValueInSfb, - pChSectionData, - pChScf, - hBitStream, - psyOutChannel[ch]->noiseNrg, - psyOutChannel[ch]->isScale, - chGlobalGain ); - if ( (hBitStream != NULL) - && (sfDataBits != (qcOutChannel[ch]->sectionData.scalefacBits + qcOutChannel[ch]->sectionData.noiseNrgBits)) ) { - error = AAC_ENC_WRITE_SCAL_ERROR; - } - bitDemand += sfDataBits; - } - break; - - case esc2_rvlc: - if (syntaxFlags & AC_ER_RVLC) { - /* write RVLC data into bitstream (error sens. cat. 2) */ - error = AAC_ENC_UNSUPPORTED_AOT; - } - break; - - case pulse: - /* Write pulse data */ - bitDemand += FDKaacEnc_encodePulseData(hBitStream); - break; - - case tns_data_present: - /* Write TNS data present flag */ - bitDemand += FDKaacEnc_encodeTnsDataPresent(pTnsInfo, - chBlockType, - hBitStream); - break; - case tns_data: - /* Write TNS data */ - bitDemand += FDKaacEnc_encodeTnsData(pTnsInfo, - chBlockType, - hBitStream); - break; - - case gain_control_data: - /* Nothing to do here */ - break; - - case gain_control_data_present: - bitDemand += FDKaacEnc_encodeGainControlData(hBitStream); - break; - - - case esc1_hcr: - //TODO: DRM! - if (syntaxFlags & AC_ER_HCR) - { - error = AAC_ENC_UNKNOWN; - } - break; - - case spectral_data: - if (hBitStream != NULL) - { - INT spectralBits = 0; - - spectralBits = FDKaacEnc_encodeSpectralData( psyOutChannel[ch]->sfbOffsets, - pChSectionData, - qcOutChannel[ch]->quantSpec, - hBitStream ); - - if (spectralBits != qcOutChannel[ch]->sectionData.huffmanBits) { - return AAC_ENC_WRITE_SPEC_ERROR; - } - bitDemand += spectralBits; - } - break; - - /* Non data cases */ - case adtscrc_start_reg1: - if (hTpEnc != NULL) { - crcReg1 = transportEnc_CrcStartReg(hTpEnc, 192); - } - break; - case adtscrc_start_reg2: - if (hTpEnc != NULL) { - crcReg2 = transportEnc_CrcStartReg(hTpEnc, 128); - } - break; - case adtscrc_end_reg1: - case drmcrc_end_reg: - if (hTpEnc != NULL) { - transportEnc_CrcEndReg(hTpEnc, crcReg1); - } - break; - case adtscrc_end_reg2: - if (hTpEnc != NULL) { - transportEnc_CrcEndReg(hTpEnc, crcReg2); - } - break; - case drmcrc_start_reg: - if (hTpEnc != NULL) { - crcReg1 = transportEnc_CrcStartReg(hTpEnc, 0); - } - break; - case next_channel: - ch = (ch + 1) % numberOfChannels; - break; - case link_sequence: - list = list->next[decision_bit]; - i=-1; - break; - - default: - error = AAC_ENC_UNKNOWN; - break; - } - - if (error != AAC_ENC_OK) { - return error; - } - - i++; - - } while (list->id[i] != end_of_sequence); - -bail: - if (pBitDemand != NULL) { - *pBitDemand = bitDemand; - } - - return error; -} - - -//----------------------------------------------------------------------------------------------- - -AAC_ENCODER_ERROR FDKaacEnc_WriteBitstream(HANDLE_TRANSPORTENC hTpEnc, - CHANNEL_MAPPING *channelMapping, - QC_OUT *qcOut, - PSY_OUT* psyOut, - QC_STATE *qcKernel, - AUDIO_OBJECT_TYPE aot, - UINT syntaxFlags, - SCHAR epConfig - ) -{ - HANDLE_FDK_BITSTREAM hBs = transportEnc_GetBitstream(hTpEnc); - AAC_ENCODER_ERROR ErrorStatus = AAC_ENC_OK; - int i, n, doByteAlign = 1; - INT bitMarkUp; - INT frameBits; - /* Get first bit of raw data block. - In case of ADTS+PCE, AU would start at PCE. - This is okay because PCE assures alignment. */ - UINT alignAnchor = FDKgetValidBits(hBs); - - frameBits = bitMarkUp = alignAnchor; - - - /* Write DSEs first in case of DAB */ - for (n = 0; (n < qcOut->nExtensions) && (n < (2+2)); n++) - { - if ( (syntaxFlags & AC_DAB) && - (qcOut->extension[n].type == EXT_DATA_ELEMENT) ) { - FDKaacEnc_writeExtensionData( hTpEnc, - &qcOut->extension[n], - 0, - alignAnchor, - syntaxFlags, - aot, - epConfig ); - } - - /* For EXT_FIL or EXT_FILL_DATA we could do an additional sanity check here */ - } - - /* Channel element loop */ - for (i=0; i<channelMapping->nElements; i++) { - - ELEMENT_INFO elInfo = channelMapping->elInfo[i]; - INT elementUsedBits = 0; - - switch (elInfo.elType) - { - case ID_SCE: /* single channel */ - case ID_CPE: /* channel pair */ - case ID_LFE: /* low freq effects channel */ - { - if ( AAC_ENC_OK != (ErrorStatus = FDKaacEnc_ChannelElementWrite( hTpEnc, - &elInfo, - qcOut->qcElement[i]->qcOutChannel, - psyOut->psyOutElement[i], - psyOut->psyOutElement[i]->psyOutChannel, - syntaxFlags, /* syntaxFlags (ER tools ...) */ - aot, /* aot: AOT_AAC_LC, AOT_SBR, AOT_PS */ - epConfig, /* epConfig -1, 0, 1 */ - NULL, - 0 )) ) - { - return ErrorStatus; - } - - if ( !(syntaxFlags & AC_ER) ) - { - /* Write associated extension payload */ - for (n = 0; n < qcOut->qcElement[i]->nExtensions; n++) { - FDKaacEnc_writeExtensionData( hTpEnc, - &qcOut->qcElement[i]->extension[n], - 0, - alignAnchor, - syntaxFlags, - aot, - epConfig ); - } - } - } - break; - - /* In FDK, DSE signalling explicit done in elDSE. See channel_map.cpp */ - default: - return AAC_ENC_INVALID_ELEMENTINFO_TYPE; - - } /* switch */ - - if(elInfo.elType != ID_DSE) { - elementUsedBits -= bitMarkUp; - bitMarkUp = FDKgetValidBits(hBs); - elementUsedBits += bitMarkUp; - frameBits += elementUsedBits; - } - - } /* for (i=0; i<channelMapping.nElements; i++) */ - - if ( (syntaxFlags & AC_ER) && !(syntaxFlags & AC_DRM) ) - { - UCHAR channelElementExtensionWritten[(8)][(1)]; /* 0: extension not touched, 1: extension already written */ - - FDKmemclear(channelElementExtensionWritten, sizeof(channelElementExtensionWritten)); - - if ( syntaxFlags & AC_ELD ) { - - for (i=0; i<channelMapping->nElements; i++) { - for (n = 0; n < qcOut->qcElement[i]->nExtensions; n++) { - - if ( (qcOut->qcElement[i]->extension[n].type==EXT_SBR_DATA) - || (qcOut->qcElement[i]->extension[n].type==EXT_SBR_DATA_CRC) ) - { - /* Write sbr extension payload */ - FDKaacEnc_writeExtensionData( hTpEnc, - &qcOut->qcElement[i]->extension[n], - 0, - alignAnchor, - syntaxFlags, - aot, - epConfig ); - - channelElementExtensionWritten[i][n] = 1; - } /* SBR */ - } /* n */ - } /* i */ - } /* AC_ELD */ - - for (i=0; i<channelMapping->nElements; i++) { - for (n = 0; n < qcOut->qcElement[i]->nExtensions; n++) { - - if (channelElementExtensionWritten[i][n]==0) - { - /* Write all remaining extension payloads in element */ - FDKaacEnc_writeExtensionData( hTpEnc, - &qcOut->qcElement[i]->extension[n], - 0, - alignAnchor, - syntaxFlags, - aot, - epConfig ); - } - } /* n */ - } /* i */ - } /* if AC_ER */ - - /* Extend global extension payload table with fill bits */ - if ( syntaxFlags & AC_DRM ) - { - /* Exception for Drm */ - for (n = 0; n < qcOut->nExtensions; n++) { - if ( (qcOut->extension[n].type == EXT_SBR_DATA) - || (qcOut->extension[n].type == EXT_SBR_DATA_CRC) ) { - /* SBR data must be the last extension! */ - FDKmemcpy(&qcOut->extension[qcOut->nExtensions], &qcOut->extension[n], sizeof(QC_OUT_EXTENSION)); - break; - } - } - /* Do byte alignment after AAC (+ MPS) payload. - Assure that MPS has been written as channel assigned extension payload! */ - if (((FDKgetValidBits(hBs)-alignAnchor+(UINT)qcOut->totFillBits)&0x7)!=(UINT)qcOut->alignBits) { - return AAC_ENC_WRITTEN_BITS_ERROR; - } - FDKaacEnc_ByteAlignment(hBs, qcOut->alignBits); - doByteAlign = 0; - - } /* AC_DRM */ - - /* Add fill data / stuffing bits */ - n = qcOut->nExtensions; - -// if (!(syntaxFlags & AC_DAB)) { - qcOut->extension[n].type = EXT_FILL_DATA; - qcOut->extension[n].nPayloadBits = qcOut->totFillBits; - qcOut->nExtensions++; -// } else { -// doByteAlign = 0; -// } - if (syntaxFlags & AC_DAB) - doByteAlign = 0; - - /* Write global extension payload and fill data */ - for (n = 0; (n < qcOut->nExtensions) && (n < (2+2)); n++) - { - if ( !(syntaxFlags & AC_DAB) || - ( (syntaxFlags & AC_DAB) && - (qcOut->extension[n].type != EXT_DATA_ELEMENT) - ) - ) { - FDKaacEnc_writeExtensionData( hTpEnc, - &qcOut->extension[n], - 0, - alignAnchor, - syntaxFlags, - aot, - epConfig ); - } - - /* For EXT_FIL or EXT_FILL_DATA we could do an additional sanity check here */ - } - - if (!(syntaxFlags & (AC_SCALABLE|AC_ER|AC_DAB))) { - FDKwriteBits(hBs, ID_END, EL_ID_BITS); - } - - if (doByteAlign) { - /* Assure byte alignment*/ - if (((alignAnchor-FDKgetValidBits(hBs))&0x7)!=(UINT)qcOut->alignBits) { - return AAC_ENC_WRITTEN_BITS_ERROR; - } - - FDKaacEnc_ByteAlignment(hBs, qcOut->alignBits); - } - - frameBits -= bitMarkUp; - frameBits += FDKgetValidBits(hBs); - - transportEnc_EndAccessUnit(hTpEnc, &frameBits); - - if (frameBits != qcOut->totalBits + qcKernel->globHdrBits){ - fprintf(stderr, "frameBits != qcOut->totalBits + qcKernel->globHdrBits: %d != %d + %d", frameBits, qcOut->totalBits, qcKernel->globHdrBits); - return AAC_ENC_WRITTEN_BITS_ERROR; - } - - //fprintf(stderr, "ErrorStatus=%d", ErrorStatus); - return ErrorStatus; -} - |