Remove FDK-AAC

1 files changed, 0 insertions, 1059 deletions

diff --git a/libSBRenc/src/bit_sbr.cpp b/libSBRenc/src/bit_sbr.cpp
deleted file mode 100644
index 963aeff..0000000
--- a/libSBRenc/src/bit_sbr.cpp
+++ /dev/null
@@ -1,1059 +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
------------------------------------------------------------------------------------------------------------ */
-
-/*!
-  \file
-  \brief  SBR bit writing routines  
-*/
-
-
-#include "bit_sbr.h"
-
-#include "code_env.h"
-#include "cmondata.h"
-#include "sbr.h"
-
-#include "ps_main.h"
-
-typedef enum {
-  SBR_ID_SCE = 1,
-  SBR_ID_CPE
-} SBR_ELEMENT_TYPE;
-
-
-static INT encodeSbrData (HANDLE_SBR_ENV_DATA       sbrEnvDataLeft,
-                          HANDLE_SBR_ENV_DATA       sbrEnvDataRight,
-                          HANDLE_PARAMETRIC_STEREO  hParametricStereo,
-                          HANDLE_COMMON_DATA        cmonData,
-                          SBR_ELEMENT_TYPE          sbrElem,
-                          INT                       coupling,
-                          UINT                      sbrSyntaxFlags);
-
-static INT encodeSbrHeader (HANDLE_SBR_HEADER_DATA     sbrHeaderData,
-                            HANDLE_SBR_BITSTREAM_DATA  sbrBitstreamData,
-                            HANDLE_COMMON_DATA         cmonData);
-
-
-static INT encodeSbrHeaderData (HANDLE_SBR_HEADER_DATA sbrHeaderData,
-                                HANDLE_FDK_BITSTREAM   hBitStream);
-
-static INT encodeSbrSingleChannelElement (HANDLE_SBR_ENV_DATA      sbrEnvData,
-                                          HANDLE_FDK_BITSTREAM     hBitStream
-                                          ,HANDLE_PARAMETRIC_STEREO hParametricStereo
-                                          ,UINT  sbrSyntaxFlags
-                                          );
-
-
-
-static INT encodeSbrChannelPairElement (HANDLE_SBR_ENV_DATA      sbrEnvDataLeft,
-                                        HANDLE_SBR_ENV_DATA      sbrEnvDataRight,
-                                        HANDLE_PARAMETRIC_STEREO hParametricStereo,
-                                        HANDLE_FDK_BITSTREAM     hBitStream,
-                                        INT                      coupling);
-
-
-static INT encodeSbrGrid (HANDLE_SBR_ENV_DATA   sbrEnvData,
-                          HANDLE_FDK_BITSTREAM  hBitStream);
-
-static int encodeLowDelaySbrGrid ( HANDLE_SBR_ENV_DATA sbrEnvData,
-                                   HANDLE_FDK_BITSTREAM hBitStream,
-                                   int transmitFreqs);
-
-static INT encodeSbrDtdf (HANDLE_SBR_ENV_DATA   sbrEnvData,
-                          HANDLE_FDK_BITSTREAM  hBitStream);
-
-static INT writeNoiseLevelData (HANDLE_SBR_ENV_DATA   sbrEnvData,
-                                HANDLE_FDK_BITSTREAM  hBitStream,
-                                INT                   coupling);
-
-static INT writeEnvelopeData (HANDLE_SBR_ENV_DATA    sbrEnvData,
-                              HANDLE_FDK_BITSTREAM   hBitStream,
-                              INT                    coupling);
-
-static INT writeSyntheticCodingData (HANDLE_SBR_ENV_DATA  sbrEnvData,
-                                     HANDLE_FDK_BITSTREAM hBitStream);
-
-
-static INT encodeExtendedData (HANDLE_PARAMETRIC_STEREO hParametricStereo,
-                               HANDLE_FDK_BITSTREAM     hBitStream);
-
-
-
-static INT getSbrExtendedDataSize (HANDLE_PARAMETRIC_STEREO  hParametricStereo);
-
-/*****************************************************************************
-
-    functionname: FDKsbrEnc_WriteEnvSingleChannelElement
-    description:  writes pure SBR single channel data element
-    returns:      number of bits written
-    input:
-    output:
-
-*****************************************************************************/
-INT
-FDKsbrEnc_WriteEnvSingleChannelElement(
-                                       HANDLE_SBR_HEADER_DATA sbrHeaderData,
-                                       HANDLE_PARAMETRIC_STEREO         hParametricStereo,
-                                       HANDLE_SBR_BITSTREAM_DATA        sbrBitstreamData,
-                                       HANDLE_SBR_ENV_DATA              sbrEnvData,
-                                       HANDLE_COMMON_DATA               cmonData,
-                                       UINT                             sbrSyntaxFlags
-                                      )
-
-{
-  INT payloadBits = 0;
-
-  cmonData->sbrHdrBits  = 0;
-  cmonData->sbrDataBits = 0;
-
-  /* write pure sbr data */
-  if (sbrEnvData != NULL) {
-
-    /* write header */
-    payloadBits += encodeSbrHeader (sbrHeaderData,
-                                    sbrBitstreamData,
-                                    cmonData);
-
-
-    /* write data */
-    payloadBits += encodeSbrData (sbrEnvData,
-                                  NULL,
-                                  hParametricStereo,
-                                  cmonData,
-                                  SBR_ID_SCE,
-                                  0,
-                                  sbrSyntaxFlags);
-
-  }
-  return payloadBits;
-}
-
-/*****************************************************************************
-
-    functionname: FDKsbrEnc_WriteEnvChannelPairElement
-    description:  writes pure SBR channel pair data element
-    returns:      number of bits written
-    input:
-    output:
-
-*****************************************************************************/
-INT
-FDKsbrEnc_WriteEnvChannelPairElement (HANDLE_SBR_HEADER_DATA     sbrHeaderData,
-                                      HANDLE_PARAMETRIC_STEREO   hParametricStereo,
-                                      HANDLE_SBR_BITSTREAM_DATA  sbrBitstreamData,
-                                      HANDLE_SBR_ENV_DATA        sbrEnvDataLeft,
-                                      HANDLE_SBR_ENV_DATA        sbrEnvDataRight,
-                                      HANDLE_COMMON_DATA         cmonData,
-                                      UINT                       sbrSyntaxFlags)
-
-{
-  INT payloadBits = 0;
-  cmonData->sbrHdrBits  = 0;
-  cmonData->sbrDataBits = 0;
-
-  /* write pure sbr data */
-  if ((sbrEnvDataLeft != NULL) && (sbrEnvDataRight != NULL)) {
-
-    /* write header */
-    payloadBits += encodeSbrHeader (sbrHeaderData,
-                                    sbrBitstreamData,
-                                    cmonData);
-
-    /* write data */
-    payloadBits += encodeSbrData (sbrEnvDataLeft,
-                                  sbrEnvDataRight,
-                                  hParametricStereo,
-                                  cmonData,
-                                  SBR_ID_CPE,
-                                  sbrHeaderData->coupling,
-                                  sbrSyntaxFlags);
-
-  }
-  return payloadBits;
-}
-
-INT
-FDKsbrEnc_CountSbrChannelPairElement (HANDLE_SBR_HEADER_DATA     sbrHeaderData,
-                                      HANDLE_PARAMETRIC_STEREO   hParametricStereo,
-                                      HANDLE_SBR_BITSTREAM_DATA  sbrBitstreamData,
-                                      HANDLE_SBR_ENV_DATA        sbrEnvDataLeft,
-                                      HANDLE_SBR_ENV_DATA        sbrEnvDataRight,
-                                      HANDLE_COMMON_DATA         cmonData,
-                                      UINT                       sbrSyntaxFlags)
-{
-  INT payloadBits;
-  INT bitPos = FDKgetValidBits(&cmonData->sbrBitbuf);
-
-  payloadBits = FDKsbrEnc_WriteEnvChannelPairElement(sbrHeaderData,
-                                           hParametricStereo,
-                                           sbrBitstreamData,
-                                           sbrEnvDataLeft,
-                                           sbrEnvDataRight,
-                                           cmonData,
-                                           sbrSyntaxFlags);
-
-  FDKpushBack(&cmonData->sbrBitbuf, (FDKgetValidBits(&cmonData->sbrBitbuf) - bitPos) );
-
-  return payloadBits;
-}
-
-
-void sbrEncoder_GetHeader(SBR_ENCODER   *sbrEncoder,
-                          HANDLE_FDK_BITSTREAM hBs,
-                          INT            element_index,
-                          int            fSendHeaders)
-{
-  int bits;
-
-  bits = encodeSbrHeaderData (&sbrEncoder->sbrElement[element_index]->sbrHeaderData, hBs);
-    
-  if (fSendHeaders == 0) {
-    /* Prevent header being embedded into the SBR payload. */
-    sbrEncoder->sbrElement[element_index]->sbrBitstreamData.NrSendHeaderData = -1;
-    sbrEncoder->sbrElement[element_index]->sbrBitstreamData.HeaderActive = 0;
-    sbrEncoder->sbrElement[element_index]->sbrBitstreamData.CountSendHeaderData = -1;
-  }
-}
-
-
-/*****************************************************************************
-
-    functionname: encodeSbrHeader
-    description:  encodes SBR Header information
-    returns:      number of bits written
-    input:
-    output:
-
-*****************************************************************************/
-static INT
-encodeSbrHeader (HANDLE_SBR_HEADER_DATA     sbrHeaderData,
-                 HANDLE_SBR_BITSTREAM_DATA  sbrBitstreamData,
-                 HANDLE_COMMON_DATA         cmonData)
-{
-  INT payloadBits = 0;
-
-  if (sbrBitstreamData->HeaderActive) {
-    payloadBits += FDKwriteBits (&cmonData->sbrBitbuf, 1, 1);
-    payloadBits += encodeSbrHeaderData (sbrHeaderData,
-                                        &cmonData->sbrBitbuf);
-  }
-  else {
-    payloadBits += FDKwriteBits (&cmonData->sbrBitbuf, 0, 1);
-  }
-
-  cmonData->sbrHdrBits = payloadBits;
-
-  return payloadBits;
-}
-
-
-
-/*****************************************************************************
-
-    functionname: encodeSbrHeaderData
-    description:  writes sbr_header()
-                  bs_protocol_version through bs_header_extra_2
-    returns:      number of bits written
-    input:
-    output:
-
-*****************************************************************************/
-static INT
-encodeSbrHeaderData (HANDLE_SBR_HEADER_DATA sbrHeaderData,
-                     HANDLE_FDK_BITSTREAM hBitStream)
-
-{
-  INT payloadBits = 0;
-  if (sbrHeaderData != NULL) {
-    payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->sbr_amp_res,
-                              SI_SBR_AMP_RES_BITS);
-    payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->sbr_start_frequency,
-                              SI_SBR_START_FREQ_BITS);
-    payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->sbr_stop_frequency,
-                              SI_SBR_STOP_FREQ_BITS);
-    payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->sbr_xover_band,
-                              SI_SBR_XOVER_BAND_BITS);
-
-    payloadBits += FDKwriteBits (hBitStream, 0,
-                              SI_SBR_RESERVED_BITS);
-
-    payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->header_extra_1,
-                              SI_SBR_HEADER_EXTRA_1_BITS);
-    payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->header_extra_2,
-                              SI_SBR_HEADER_EXTRA_2_BITS);
-
-
-    if (sbrHeaderData->header_extra_1) {
-      payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->freqScale,
-                                SI_SBR_FREQ_SCALE_BITS);
-      payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->alterScale,
-                                SI_SBR_ALTER_SCALE_BITS);
-      payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->sbr_noise_bands,
-                                SI_SBR_NOISE_BANDS_BITS);
-    } /* sbrHeaderData->header_extra_1 */
-
-    if (sbrHeaderData->header_extra_2) {
-      payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->sbr_limiter_bands,
-                                SI_SBR_LIMITER_BANDS_BITS);
-      payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->sbr_limiter_gains,
-                                SI_SBR_LIMITER_GAINS_BITS);
-      payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->sbr_interpol_freq,
-                                SI_SBR_INTERPOL_FREQ_BITS);
-      payloadBits += FDKwriteBits (hBitStream, sbrHeaderData->sbr_smoothing_length,
-                                SI_SBR_SMOOTHING_LENGTH_BITS);
-
-    } /* sbrHeaderData->header_extra_2 */
-  } /* sbrHeaderData != NULL */
-
-  return payloadBits;
-}
-
-
-/*****************************************************************************
-
-    functionname: encodeSbrData
-    description:  encodes sbr Data information
-    returns:      number of bits written
-    input:
-    output:
-
-*****************************************************************************/
-static INT
-encodeSbrData (HANDLE_SBR_ENV_DATA   sbrEnvDataLeft,
-               HANDLE_SBR_ENV_DATA   sbrEnvDataRight,
-               HANDLE_PARAMETRIC_STEREO   hParametricStereo,
-               HANDLE_COMMON_DATA    cmonData,
-               SBR_ELEMENT_TYPE      sbrElem,
-               INT                   coupling,
-               UINT                  sbrSyntaxFlags)
-{
-  INT payloadBits = 0;
-
-  switch (sbrElem) {
-  case SBR_ID_SCE:
-    payloadBits += encodeSbrSingleChannelElement (sbrEnvDataLeft, &cmonData->sbrBitbuf, hParametricStereo, sbrSyntaxFlags);
-    break;
-  case SBR_ID_CPE:
-    payloadBits += encodeSbrChannelPairElement (sbrEnvDataLeft, sbrEnvDataRight, hParametricStereo, &cmonData->sbrBitbuf, coupling);
-    break;
-  default:
-    /* we never should apply SBR to any other element type */
-    FDK_ASSERT (0);
-  }
-
-  cmonData->sbrDataBits = payloadBits;
-
-  return payloadBits;
-}
-
-#define MODE_FREQ_TANS                          1
-#define MODE_NO_FREQ_TRAN                       0
-#define LD_TRANSMISSION                         MODE_FREQ_TANS
-static int encodeFreqs (int mode) {
-    return ((mode & MODE_FREQ_TANS) ? 1 : 0);
-}
-
-
-/*****************************************************************************
-
-    functionname: encodeSbrSingleChannelElement
-    description:  encodes sbr SCE information
-    returns:      number of bits written
-    input:
-    output:
-
-*****************************************************************************/
-static INT
-encodeSbrSingleChannelElement (HANDLE_SBR_ENV_DATA   sbrEnvData,
-                               HANDLE_FDK_BITSTREAM  hBitStream
-                               ,HANDLE_PARAMETRIC_STEREO hParametricStereo
-                               ,UINT  sbrSyntaxFlags
-                               )
-{
-  INT i, payloadBits = 0;
-
-  payloadBits += FDKwriteBits (hBitStream, 0, SI_SBR_DATA_EXTRA_BITS); /* no reserved bits */
-
-  if (sbrEnvData->ldGrid) {
-      if ( sbrEnvData->hSbrBSGrid->frameClass != FIXFIXonly ) {
-        /* encode normal SbrGrid */
-        payloadBits += encodeSbrGrid (sbrEnvData, hBitStream);
-      } else {
-        /* use FIXFIXonly frame Grid */
-        payloadBits += encodeLowDelaySbrGrid ( sbrEnvData, hBitStream, encodeFreqs(LD_TRANSMISSION));
-      }
-  }
-  else
-  {
-    if (sbrSyntaxFlags & SBR_SYNTAX_SCALABLE) {
-      payloadBits += FDKwriteBits (hBitStream, 1, SI_SBR_COUPLING_BITS);
-    }
-    payloadBits += encodeSbrGrid (sbrEnvData, hBitStream);
-  }
-
-  payloadBits += encodeSbrDtdf (sbrEnvData, hBitStream);
-
-  for (i = 0; i < sbrEnvData->noOfnoisebands; i++) {
-    payloadBits += FDKwriteBits (hBitStream, sbrEnvData->sbr_invf_mode_vec[i], SI_SBR_INVF_MODE_BITS);
-  }
-
-  payloadBits += writeEnvelopeData (sbrEnvData, hBitStream, 0);
-  payloadBits += writeNoiseLevelData (sbrEnvData, hBitStream, 0);
-
-  payloadBits += writeSyntheticCodingData (sbrEnvData,hBitStream);
-
-  payloadBits += encodeExtendedData(hParametricStereo, hBitStream);
-
-  return payloadBits;
-}
-
-
-/*****************************************************************************
-
-    functionname: encodeSbrChannelPairElement
-    description:  encodes sbr CPE information
-    returns:
-    input:
-    output:
-
-*****************************************************************************/
-static INT
-encodeSbrChannelPairElement (HANDLE_SBR_ENV_DATA   sbrEnvDataLeft,
-                             HANDLE_SBR_ENV_DATA   sbrEnvDataRight,
-                             HANDLE_PARAMETRIC_STEREO   hParametricStereo,
-                             HANDLE_FDK_BITSTREAM  hBitStream,
-                             INT                   coupling)
-{
-  INT payloadBits = 0;
-  INT i = 0;
-
-  payloadBits += FDKwriteBits (hBitStream, 0, SI_SBR_DATA_EXTRA_BITS); /* no reserved bits */
-
-  payloadBits += FDKwriteBits (hBitStream, coupling, SI_SBR_COUPLING_BITS);
-
-  if (coupling) {
-    if (sbrEnvDataLeft->ldGrid) {
-          if ( sbrEnvDataLeft->hSbrBSGrid->frameClass != FIXFIXonly ) {
-            /* normal SbrGrid */
-            payloadBits += encodeSbrGrid (sbrEnvDataLeft, hBitStream);
-
-          } else {
-              /* FIXFIXonly frame Grid */
-              payloadBits += encodeLowDelaySbrGrid ( sbrEnvDataLeft, hBitStream, encodeFreqs(LD_TRANSMISSION));
-          }
-    } else
-        payloadBits += encodeSbrGrid (sbrEnvDataLeft, hBitStream);
-
-    payloadBits += encodeSbrDtdf (sbrEnvDataLeft, hBitStream);
-    payloadBits += encodeSbrDtdf (sbrEnvDataRight, hBitStream);
-
-    for (i = 0; i < sbrEnvDataLeft->noOfnoisebands; i++) {
-      payloadBits += FDKwriteBits (hBitStream, sbrEnvDataLeft->sbr_invf_mode_vec[i], SI_SBR_INVF_MODE_BITS);
-    }
-
-    payloadBits += writeEnvelopeData  (sbrEnvDataLeft,  hBitStream,1);
-    payloadBits += writeNoiseLevelData (sbrEnvDataLeft,  hBitStream,1);
-    payloadBits += writeEnvelopeData  (sbrEnvDataRight, hBitStream,1);
-    payloadBits += writeNoiseLevelData (sbrEnvDataRight, hBitStream,1);
-
-    payloadBits += writeSyntheticCodingData (sbrEnvDataLeft,hBitStream);
-    payloadBits += writeSyntheticCodingData (sbrEnvDataRight,hBitStream);
-
-  } else { /* no coupling */
-    FDK_ASSERT(sbrEnvDataLeft->ldGrid == sbrEnvDataRight->ldGrid);
-
-    if (sbrEnvDataLeft->ldGrid || sbrEnvDataRight->ldGrid) {
-    /* sbrEnvDataLeft (left channel) */
-      if ( sbrEnvDataLeft->hSbrBSGrid->frameClass != FIXFIXonly) {
-        /* no FIXFIXonly Frame so we dont need encodeLowDelaySbrGrid */
-        /* normal SbrGrid */
-        payloadBits += encodeSbrGrid (sbrEnvDataLeft,  hBitStream);
-
-      } else {
-        /* FIXFIXonly frame Grid */
-          payloadBits += encodeLowDelaySbrGrid ( sbrEnvDataLeft, hBitStream, encodeFreqs(LD_TRANSMISSION));
-      }
-
-      /* sbrEnvDataRight (right channel) */
-      if ( sbrEnvDataRight->hSbrBSGrid->frameClass != FIXFIXonly) {
-        /* no FIXFIXonly Frame so we dont need encodeLowDelaySbrGrid */
-        /* normal SbrGrid */
-        payloadBits += encodeSbrGrid (sbrEnvDataRight, hBitStream);
-
-      } else {
-        /* FIXFIXonly frame Grid */
-          payloadBits += encodeLowDelaySbrGrid ( sbrEnvDataRight, hBitStream, encodeFreqs(LD_TRANSMISSION));
-      }
-    } else
-    {
-        payloadBits += encodeSbrGrid (sbrEnvDataLeft,  hBitStream);
-        payloadBits += encodeSbrGrid (sbrEnvDataRight, hBitStream);
-    }
-    payloadBits += encodeSbrDtdf (sbrEnvDataLeft,  hBitStream);
-    payloadBits += encodeSbrDtdf (sbrEnvDataRight, hBitStream);
-
-    for (i = 0; i < sbrEnvDataLeft->noOfnoisebands; i++) {
-      payloadBits += FDKwriteBits (hBitStream, sbrEnvDataLeft->sbr_invf_mode_vec[i],
-                                SI_SBR_INVF_MODE_BITS);
-    }
-    for (i = 0; i < sbrEnvDataRight->noOfnoisebands; i++) {
-      payloadBits += FDKwriteBits (hBitStream, sbrEnvDataRight->sbr_invf_mode_vec[i],
-                                SI_SBR_INVF_MODE_BITS);
-    }
-
-    payloadBits += writeEnvelopeData  (sbrEnvDataLeft,  hBitStream,0);
-    payloadBits += writeEnvelopeData  (sbrEnvDataRight, hBitStream,0);
-    payloadBits += writeNoiseLevelData (sbrEnvDataLeft,  hBitStream,0);
-    payloadBits += writeNoiseLevelData (sbrEnvDataRight, hBitStream,0);
-
-    payloadBits += writeSyntheticCodingData (sbrEnvDataLeft,hBitStream);
-    payloadBits += writeSyntheticCodingData (sbrEnvDataRight,hBitStream);
-
-  } /* coupling */
-
-  payloadBits += encodeExtendedData(hParametricStereo, hBitStream);
-
-  return payloadBits;
-}
-
-static INT ceil_ln2(INT x)
-{
-  INT tmp=-1;
-  while((1<<++tmp) < x);
-  return(tmp);
-}
-
-
-/*****************************************************************************
-
-    functionname: encodeSbrGrid
-    description:  if hBitStream != NULL writes bits that describes the
-                  time/frequency grouping of a frame; else counts them only
-    returns:      number of bits written or counted
-    input:
-    output:
-
-*****************************************************************************/
-static INT
-encodeSbrGrid (HANDLE_SBR_ENV_DATA sbrEnvData, HANDLE_FDK_BITSTREAM hBitStream)
-{
-  INT payloadBits = 0;
-  INT i, temp;
-  INT bufferFrameStart = sbrEnvData->hSbrBSGrid->bufferFrameStart;
-  INT numberTimeSlots  = sbrEnvData->hSbrBSGrid->numberTimeSlots;
-
-  if (sbrEnvData->ldGrid)
-    payloadBits += FDKwriteBits (hBitStream,
-                                 sbrEnvData->hSbrBSGrid->frameClass,
-                                 SBR_CLA_BITS_LD);
-  else
-    payloadBits += FDKwriteBits (hBitStream,
-                                 sbrEnvData->hSbrBSGrid->frameClass,
-                                 SBR_CLA_BITS);
-
-  switch (sbrEnvData->hSbrBSGrid->frameClass) {
-  case FIXFIXonly:
-    FDK_ASSERT(0 /* Fatal error in encodeSbrGrid! */);
-    break;
-  case FIXFIX:
-    temp = ceil_ln2(sbrEnvData->hSbrBSGrid->bs_num_env);
-    payloadBits += FDKwriteBits (hBitStream, temp, SBR_ENV_BITS);
-    if ((sbrEnvData->ldGrid) && (sbrEnvData->hSbrBSGrid->bs_num_env==1))
-      payloadBits += FDKwriteBits(hBitStream, sbrEnvData->currentAmpResFF, SI_SBR_AMP_RES_BITS);
-    payloadBits += FDKwriteBits (hBitStream, sbrEnvData->hSbrBSGrid->v_f[0], SBR_RES_BITS);
-
-    break;
-
-  case FIXVAR:
-  case VARFIX:
-    if (sbrEnvData->hSbrBSGrid->frameClass == FIXVAR)
-      temp = sbrEnvData->hSbrBSGrid->bs_abs_bord - (bufferFrameStart + numberTimeSlots);
-    else
-      temp = sbrEnvData->hSbrBSGrid->bs_abs_bord - bufferFrameStart;
-
-    payloadBits += FDKwriteBits (hBitStream, temp, SBR_ABS_BITS);
-    payloadBits += FDKwriteBits (hBitStream, sbrEnvData->hSbrBSGrid->n, SBR_NUM_BITS);
-
-    for (i = 0; i < sbrEnvData->hSbrBSGrid->n; i++) {
-      temp = (sbrEnvData->hSbrBSGrid->bs_rel_bord[i] - 2) >> 1;
-      payloadBits += FDKwriteBits (hBitStream, temp, SBR_REL_BITS);
-    }
-
-    temp = ceil_ln2(sbrEnvData->hSbrBSGrid->n + 2);
-    payloadBits += FDKwriteBits (hBitStream, sbrEnvData->hSbrBSGrid->p, temp);
-
-    for (i = 0; i < sbrEnvData->hSbrBSGrid->n + 1; i++) {
-      payloadBits += FDKwriteBits (hBitStream, sbrEnvData->hSbrBSGrid->v_f[i],
-                                SBR_RES_BITS);
-    }
-    break;
-
-  case VARVAR:
-    temp = sbrEnvData->hSbrBSGrid->bs_abs_bord_0 - bufferFrameStart;
-    payloadBits += FDKwriteBits (hBitStream, temp, SBR_ABS_BITS);
-    temp = sbrEnvData->hSbrBSGrid->bs_abs_bord_1 - (bufferFrameStart + numberTimeSlots);
-    payloadBits += FDKwriteBits (hBitStream, temp, SBR_ABS_BITS);
-
-    payloadBits += FDKwriteBits (hBitStream, sbrEnvData->hSbrBSGrid->bs_num_rel_0, SBR_NUM_BITS);
-    payloadBits += FDKwriteBits (hBitStream, sbrEnvData->hSbrBSGrid->bs_num_rel_1, SBR_NUM_BITS);
-
-    for (i = 0; i < sbrEnvData->hSbrBSGrid->bs_num_rel_0; i++) {
-      temp = (sbrEnvData->hSbrBSGrid->bs_rel_bord_0[i] - 2) >> 1;
-      payloadBits += FDKwriteBits (hBitStream, temp, SBR_REL_BITS);
-    }
-
-    for (i = 0; i < sbrEnvData->hSbrBSGrid->bs_num_rel_1; i++) {
-      temp = (sbrEnvData->hSbrBSGrid->bs_rel_bord_1[i] - 2) >> 1;
-      payloadBits += FDKwriteBits (hBitStream, temp, SBR_REL_BITS);
-    }
-
-    temp = ceil_ln2(sbrEnvData->hSbrBSGrid->bs_num_rel_0 +
-                             sbrEnvData->hSbrBSGrid->bs_num_rel_1 + 2);
-    payloadBits +=  FDKwriteBits (hBitStream, sbrEnvData->hSbrBSGrid->p, temp);
-
-    temp = sbrEnvData->hSbrBSGrid->bs_num_rel_0 +
-           sbrEnvData->hSbrBSGrid->bs_num_rel_1 + 1;
-
-    for (i = 0; i < temp; i++) {
-      payloadBits += FDKwriteBits (hBitStream, sbrEnvData->hSbrBSGrid->v_fLR[i],
-                                SBR_RES_BITS);
-    }
-    break;
-  }
-
-  return payloadBits;
-}
-
-#define SBR_CLA_BITS_LD 1
-/*****************************************************************************
-
-    functionname: encodeLowDelaySbrGrid
-    description:  if hBitStream != NULL writes bits that describes the
-                  time/frequency grouping of a frame;
-                  else counts them only
-                  (this function only write the FIXFIXonly Bitstream data)
-    returns:      number of bits written or counted
-    input:
-    output:
-
-*****************************************************************************/
-static int
-encodeLowDelaySbrGrid (  HANDLE_SBR_ENV_DATA sbrEnvData,
-                         HANDLE_FDK_BITSTREAM hBitStream,
-                         int transmitFreqs
-                       )
-{
-  int payloadBits = 0;
-  int i;
-
-  /* write FIXFIXonly Grid */
-  /* write frameClass [1 bit] for FIXFIXonly Grid */
-  payloadBits += FDKwriteBits(hBitStream, 1, SBR_CLA_BITS_LD);
-
-  /* absolute Borders are fix: 0,X,X,X,nTimeSlots; so we dont have to transmit them */
-  /* only transmit the transient position! */
-  /* with this info (b1) we can reconstruct the Frame on Decoder side : */
-  /* border[0] = 0; border[1] = b1; border[2]=b1+2; border[3] = nrTimeSlots */
-
-  /* use 3 or 4bits for transient border (border) */
-  if (sbrEnvData->hSbrBSGrid->numberTimeSlots == 8)
-    payloadBits += FDKwriteBits ( hBitStream, sbrEnvData->hSbrBSGrid->bs_abs_bord, 3);
-  else
-    payloadBits += FDKwriteBits ( hBitStream, sbrEnvData->hSbrBSGrid->bs_abs_bord, 4);
-
-  if (transmitFreqs) {
-    /* write FreqRes grid */
-    for (i = 0; i < sbrEnvData->hSbrBSGrid->bs_num_env; i++) {
-      payloadBits += FDKwriteBits (hBitStream, sbrEnvData->hSbrBSGrid->v_f[i], SBR_RES_BITS);
-    }
-  }
-
-  return payloadBits;
-}
-
-/*****************************************************************************
-
-    functionname: encodeSbrDtdf
-    description:  writes bits that describes the direction of the envelopes of a frame
-    returns:      number of bits written
-    input:
-    output:
-
-*****************************************************************************/
-static INT
-encodeSbrDtdf (HANDLE_SBR_ENV_DATA sbrEnvData, HANDLE_FDK_BITSTREAM hBitStream)
-{
-  INT i, payloadBits = 0, noOfNoiseEnvelopes;
-
-  noOfNoiseEnvelopes = sbrEnvData->noOfEnvelopes > 1 ? 2 : 1;
-
-  for (i = 0; i < sbrEnvData->noOfEnvelopes; ++i) {
-    payloadBits += FDKwriteBits (hBitStream, sbrEnvData->domain_vec[i], SBR_DIR_BITS);
-  }
-  for (i = 0; i < noOfNoiseEnvelopes; ++i) {
-    payloadBits +=  FDKwriteBits (hBitStream, sbrEnvData->domain_vec_noise[i], SBR_DIR_BITS);
-  }
-
-  return payloadBits;
-}
-
-
-/*****************************************************************************
-
-    functionname: writeNoiseLevelData
-    description:  writes bits corresponding to the noise-floor-level
-    returns:      number of bits written
-    input:
-    output:
-
-*****************************************************************************/
-static INT
-writeNoiseLevelData (HANDLE_SBR_ENV_DATA sbrEnvData, HANDLE_FDK_BITSTREAM hBitStream, INT coupling)
-{
-  INT j, i, payloadBits = 0;
-  INT nNoiseEnvelopes = sbrEnvData->noOfEnvelopes > 1 ? 2 : 1;
-
-  for (i = 0; i < nNoiseEnvelopes; i++) {
-    switch (sbrEnvData->domain_vec_noise[i]) {
-    case FREQ:
-      if (coupling && sbrEnvData->balance) {
-        payloadBits += FDKwriteBits (hBitStream,
-                                  sbrEnvData->sbr_noise_levels[i * sbrEnvData->noOfnoisebands],
-                                  sbrEnvData->si_sbr_start_noise_bits_balance);
-      } else {
-        payloadBits += FDKwriteBits (hBitStream,
-                                  sbrEnvData->sbr_noise_levels[i * sbrEnvData->noOfnoisebands],
-                                  sbrEnvData->si_sbr_start_noise_bits);
-      }
-
-      for (j = 1 + i * sbrEnvData->noOfnoisebands; j < (sbrEnvData->noOfnoisebands * (1 + i)); j++) {
-        if (coupling) {
-          if (sbrEnvData->balance) {
-            /* coupling && balance */
-            payloadBits += FDKwriteBits (hBitStream,
-                                      sbrEnvData->hufftableNoiseBalanceFreqC[sbrEnvData->sbr_noise_levels[j] +
-                                                                            CODE_BOOK_SCF_LAV_BALANCE11],
-                                      sbrEnvData->hufftableNoiseBalanceFreqL[sbrEnvData->sbr_noise_levels[j] +
-                                                                            CODE_BOOK_SCF_LAV_BALANCE11]);
-          } else {
-            /* coupling && !balance */
-            payloadBits += FDKwriteBits (hBitStream,
-                                      sbrEnvData->hufftableNoiseLevelFreqC[sbrEnvData->sbr_noise_levels[j] +
-                                                                          CODE_BOOK_SCF_LAV11],
-                                      sbrEnvData->hufftableNoiseLevelFreqL[sbrEnvData->sbr_noise_levels[j] +
-                                                                          CODE_BOOK_SCF_LAV11]);
-          }
-        } else {
-          /* !coupling */
-          payloadBits += FDKwriteBits (hBitStream,
-                                    sbrEnvData->hufftableNoiseFreqC[sbrEnvData->sbr_noise_levels[j] +
-                                                                   CODE_BOOK_SCF_LAV11],
-                                    sbrEnvData->hufftableNoiseFreqL[sbrEnvData->sbr_noise_levels[j] +
-                                                                   CODE_BOOK_SCF_LAV11]);
-        }
-      }
-      break;
-
-    case TIME:
-      for (j = i * sbrEnvData->noOfnoisebands; j < (sbrEnvData->noOfnoisebands * (1 + i)); j++) {
-        if (coupling) {
-          if (sbrEnvData->balance) {
-            /* coupling && balance */
-            payloadBits += FDKwriteBits (hBitStream,
-                                      sbrEnvData->hufftableNoiseBalanceTimeC[sbrEnvData->sbr_noise_levels[j] +
-                                                                            CODE_BOOK_SCF_LAV_BALANCE11],
-                                      sbrEnvData->hufftableNoiseBalanceTimeL[sbrEnvData->sbr_noise_levels[j] +
-                                                                            CODE_BOOK_SCF_LAV_BALANCE11]);
-          } else {
-            /* coupling && !balance */
-            payloadBits += FDKwriteBits (hBitStream,
-                                      sbrEnvData->hufftableNoiseLevelTimeC[sbrEnvData->sbr_noise_levels[j] +
-                                                                          CODE_BOOK_SCF_LAV11],
-                                      sbrEnvData->hufftableNoiseLevelTimeL[sbrEnvData->sbr_noise_levels[j] +
-                                                                          CODE_BOOK_SCF_LAV11]);
-          }
-        } else {
-          /* !coupling */
-          payloadBits += FDKwriteBits (hBitStream,
-                                    sbrEnvData->hufftableNoiseLevelTimeC[sbrEnvData->sbr_noise_levels[j] +
-                                                                        CODE_BOOK_SCF_LAV11],
-                                    sbrEnvData->hufftableNoiseLevelTimeL[sbrEnvData->sbr_noise_levels[j] +
-                                                                        CODE_BOOK_SCF_LAV11]);
-        }
-      }
-      break;
-    }
-  }
-  return payloadBits;
-}
-
-
-/*****************************************************************************
-
-    functionname: writeEnvelopeData
-    description:  writes bits corresponding to the envelope
-    returns:      number of bits written
-    input:
-    output:
-
-*****************************************************************************/
-static INT
-writeEnvelopeData (HANDLE_SBR_ENV_DATA sbrEnvData, HANDLE_FDK_BITSTREAM hBitStream, INT coupling)
-{
-  INT payloadBits = 0, j, i, delta;
-
-  for (j = 0; j < sbrEnvData->noOfEnvelopes; j++) { /* loop over all envelopes */
-    if (sbrEnvData->domain_vec[j] == FREQ) {
-      if (coupling && sbrEnvData->balance) {
-        payloadBits += FDKwriteBits (hBitStream, sbrEnvData->ienvelope[j][0], sbrEnvData->si_sbr_start_env_bits_balance);
-      } else {
-        payloadBits += FDKwriteBits (hBitStream, sbrEnvData->ienvelope[j][0], sbrEnvData->si_sbr_start_env_bits);
-      }
-    }
-
-    for (i = 1 - sbrEnvData->domain_vec[j]; i < sbrEnvData->noScfBands[j]; i++) {
-      delta = sbrEnvData->ienvelope[j][i];
-      if (coupling && sbrEnvData->balance) {
-        FDK_ASSERT (fixp_abs (delta) <= sbrEnvData->codeBookScfLavBalance);
-      } else {
-        FDK_ASSERT (fixp_abs (delta) <= sbrEnvData->codeBookScfLav);
-      }
-      if (coupling) {
-        if (sbrEnvData->balance) {
-          if (sbrEnvData->domain_vec[j]) {
-            /* coupling && balance && TIME */
-            payloadBits += FDKwriteBits (hBitStream,
-                                      sbrEnvData->hufftableBalanceTimeC[delta + sbrEnvData->codeBookScfLavBalance],
-                                      sbrEnvData->hufftableBalanceTimeL[delta + sbrEnvData->codeBookScfLavBalance]);
-          } else {
-            /* coupling && balance && FREQ */
-            payloadBits += FDKwriteBits (hBitStream,
-                                      sbrEnvData->hufftableBalanceFreqC[delta + sbrEnvData->codeBookScfLavBalance],
-                                      sbrEnvData->hufftableBalanceFreqL[delta + sbrEnvData->codeBookScfLavBalance]);
-          }
-        } else {
-          if (sbrEnvData->domain_vec[j]) {
-            /* coupling && !balance && TIME */
-            payloadBits += FDKwriteBits (hBitStream,
-                                      sbrEnvData->hufftableLevelTimeC[delta + sbrEnvData->codeBookScfLav],
-                                      sbrEnvData->hufftableLevelTimeL[delta + sbrEnvData->codeBookScfLav]);
-          } else {
-            /* coupling && !balance && FREQ */
-            payloadBits += FDKwriteBits (hBitStream,
-                                      sbrEnvData->hufftableLevelFreqC[delta + sbrEnvData->codeBookScfLav],
-                                      sbrEnvData->hufftableLevelFreqL[delta + sbrEnvData->codeBookScfLav]);
-          }
-        }
-      } else {
-        if (sbrEnvData->domain_vec[j]) {
-          /* !coupling && TIME */
-          payloadBits += FDKwriteBits (hBitStream,
-                                    sbrEnvData->hufftableTimeC[delta + sbrEnvData->codeBookScfLav],
-                                    sbrEnvData->hufftableTimeL[delta + sbrEnvData->codeBookScfLav]);
-        } else {
-          /* !coupling && FREQ */
-          payloadBits += FDKwriteBits (hBitStream,
-                                    sbrEnvData->hufftableFreqC[delta + sbrEnvData->codeBookScfLav],
-                                    sbrEnvData->hufftableFreqL[delta + sbrEnvData->codeBookScfLav]);
-        }
-      }
-    }
-  }
-  return payloadBits;
-}
-
-
-/*****************************************************************************
-
-    functionname: encodeExtendedData
-    description:  writes bits corresponding to the extended data
-    returns:      number of bits written
-    input:
-    output:
-
-*****************************************************************************/
-static INT encodeExtendedData (HANDLE_PARAMETRIC_STEREO  hParametricStereo,
-                               HANDLE_FDK_BITSTREAM hBitStream)
-{
-  INT extDataSize;
-  INT payloadBits = 0;
-
-  extDataSize = getSbrExtendedDataSize(hParametricStereo);
-
-
-  if (extDataSize != 0) {
-    INT maxExtSize = (1<<SI_SBR_EXTENSION_SIZE_BITS) - 1;
-    INT writtenNoBits = 0; /* needed to byte align the extended data */
-
-    payloadBits += FDKwriteBits (hBitStream, 1, SI_SBR_EXTENDED_DATA_BITS);
-    FDK_ASSERT(extDataSize <= SBR_EXTENDED_DATA_MAX_CNT);
-
-    if (extDataSize < maxExtSize) {
-      payloadBits += FDKwriteBits (hBitStream, extDataSize, SI_SBR_EXTENSION_SIZE_BITS);
-    } else {
-      payloadBits += FDKwriteBits (hBitStream, maxExtSize, SI_SBR_EXTENSION_SIZE_BITS);
-      payloadBits += FDKwriteBits (hBitStream, extDataSize - maxExtSize, SI_SBR_EXTENSION_ESC_COUNT_BITS);
-    }
-
-    /* parametric coding signalled here? */
-    if(hParametricStereo){
-      writtenNoBits += FDKwriteBits (hBitStream, EXTENSION_ID_PS_CODING, SI_SBR_EXTENSION_ID_BITS);
-      writtenNoBits += FDKsbrEnc_PSEnc_WritePSData(hParametricStereo, hBitStream);
-    }
-
-    payloadBits += writtenNoBits;
-
-    /* byte alignment */
-    writtenNoBits = writtenNoBits%8;
-    if(writtenNoBits)
-      payloadBits += FDKwriteBits(hBitStream, 0, (8 - writtenNoBits));
-  } else {
-    payloadBits += FDKwriteBits (hBitStream, 0, SI_SBR_EXTENDED_DATA_BITS);
-  }
-
-  return payloadBits;
-}
-
-
-/*****************************************************************************
-
-    functionname: writeSyntheticCodingData
-    description:  writes bits corresponding to the "synthetic-coding"-extension
-    returns:      number of bits written
-    input:
-    output:
-
-*****************************************************************************/
-static INT writeSyntheticCodingData (HANDLE_SBR_ENV_DATA  sbrEnvData,
-                                     HANDLE_FDK_BITSTREAM hBitStream)
-
-{
-  INT i;
-  INT payloadBits = 0;
-
-  payloadBits += FDKwriteBits (hBitStream, sbrEnvData->addHarmonicFlag, 1);
-
-  if (sbrEnvData->addHarmonicFlag) {
-    for (i = 0; i < sbrEnvData->noHarmonics; i++) {
-      payloadBits += FDKwriteBits (hBitStream, sbrEnvData->addHarmonic[i], 1);
-    }
-  }
-
-  return payloadBits;
-}
-
-/*****************************************************************************
-
-    functionname: getSbrExtendedDataSize
-    description:  counts the number of bits needed for encoding the
-                  extended data (including extension id)
-
-    returns:      number of bits needed for the extended data
-    input:
-    output:
-
-*****************************************************************************/
-static INT
-getSbrExtendedDataSize (HANDLE_PARAMETRIC_STEREO  hParametricStereo)
-{
-  INT extDataBits = 0;
-
-  /* add your new extended data counting methods here */
-
-  /*
-    no extended data
-  */
-
-  if(hParametricStereo){
-    /* PS extended data */
-    extDataBits += SI_SBR_EXTENSION_ID_BITS;
-    extDataBits += FDKsbrEnc_PSEnc_WritePSData(hParametricStereo, NULL);
-  }
-
-  return (extDataBits+7) >> 3;
-}
-
-
-
-
-