Fraunhofer AAC codec.

License boilerplate update to follow.

Change-Id: I2810460c11a58b6d148d84673cc031f3685e79b5

1 files changed, 952 insertions, 0 deletions

diff --git a/libAACenc/src/aacenc.cpp b/libAACenc/src/aacenc.cpp
new file mode 100644
index 0000000..5ab7192
--- /dev/null
+++ b/libAACenc/src/aacenc.cpp
@@ -0,0 +1,952 @@
+/***************************  Fast MPEG AAC Audio Encoder  **********************
+
+                     (C) Copyright Fraunhofer IIS (1999)
+                               All Rights Reserved
+
+    Please be advised that this software and/or program delivery is
+    Confidential Information of Fraunhofer and subject to and covered by the
+
+    Fraunhofer IIS Software Evaluation Agreement
+    between Google Inc. and  Fraunhofer
+    effective and in full force since March 1, 2012.
+
+    You may use this software and/or program only under the terms and
+    conditions described in the above mentioned Fraunhofer IIS Software
+    Evaluation Agreement. Any other and/or further use requires a separate agreement.
+
+
+   This software and/or program is protected by copyright law and international
+   treaties. Any reproduction or distribution of this software and/or program,
+   or any portion of it, may result in severe civil and criminal penalties, and
+   will be prosecuted to the maximum extent possible under law.
+
+   $Id$
+   Initial author:       M. Schug / A. Groeschel
+   contents/description: fast aac coder functions
+
+******************************************************************************/
+
+#include "aacenc.h"
+
+#include "bitenc.h"
+#include "interface.h"
+#include "psy_configuration.h"
+#include "psy_main.h"
+#include "qc_main.h"
+#include "bandwidth.h"
+#include "channel_map.h"
+#include "tns_func.h"
+#include "aacEnc_ram.h"
+
+#include "genericStds.h"
+
+
+
+
+static AAC_ENCODER_ERROR FDKaacEnc_InitCheckAncillary(INT bitRate,
+                                                      INT framelength,
+                                                      INT ancillaryRate,
+                                                      INT *ancillaryBitsPerFrame,
+                                                      INT sampleRate);
+
+/**
+ * For calculating average bitrate of an access unit 32 bit data width is not sufficient
+ * in worst case. Therefore use scaling of the samplingrate parameter to keep complete information.
+ */
+typedef struct {
+    INT   samplingRate;
+    UCHAR scalingFactor;
+} SR_SCALING_TAB;
+
+static const SR_SCALING_TAB samplingRateScalingTable[] =
+{
+  {  8000, 5 }, { 11025, 0 }, { 12000, 5 }, { 16000, 5 },
+  { 22050, 1 }, { 24000, 5 }, { 32000, 5 }, { 44100, 2 },
+  { 48000, 5 }, { 64000, 5 }, { 88200, 3 }, { 96000, 5 }
+};
+
+/**
+ * Get maximal scaling factor without losing samplingrate accuracy.
+ *
+ * \param  samplingRate Samplingrate to be used.
+ * \return scaling value.
+ */
+static int GetSrSf(const INT samplingRate)
+{
+  int i, result = 0;
+
+  for (i=0; i<(int)(sizeof(samplingRateScalingTable)/sizeof(SR_SCALING_TAB)); i++) {
+    if ( samplingRateScalingTable[i].samplingRate == samplingRate ) {
+      result = samplingRateScalingTable[i].scalingFactor;
+      break;
+    }
+  }
+  return result;
+}
+
+#define MIN_BUFSIZE_PER_EFF_CHAN 6144
+
+typedef struct
+{
+  AACENC_BITRATE_MODE bitrateMode;
+  int chanBitrate[2]; /* mono/stereo settings */
+} CONFIG_TAB_ENTRY_VBR;
+
+static const CONFIG_TAB_ENTRY_VBR configTabVBR[] = {
+  {AACENC_BR_MODE_CBR,   {     0,     0}} ,
+  {AACENC_BR_MODE_VBR_1, { 32000, 20000}} ,
+  {AACENC_BR_MODE_VBR_2, { 40000, 32000}} ,
+  {AACENC_BR_MODE_VBR_3, { 56000, 48000}} ,
+  {AACENC_BR_MODE_VBR_4, { 72000, 64000}} ,
+  {AACENC_BR_MODE_VBR_5, {112000, 96000}}
+};
+
+/*-----------------------------------------------------------------------------
+
+     functionname: FDKaacEnc_GetVBRBitrate
+     description:  Get VBR bitrate from vbr quality
+     input params: int vbrQuality (VBR0, VBR1, VBR2)
+                   channelMode
+     returns:      vbr bitrate
+
+ ------------------------------------------------------------------------------*/
+INT FDKaacEnc_GetVBRBitrate(INT bitrateMode, CHANNEL_MODE channelMode)
+{
+  INT bitrate = 0;
+  INT monoStereoMode = 0; /* default mono */
+
+  if (FDKaacEnc_GetMonoStereoMode(channelMode)==EL_MODE_STEREO) {
+      monoStereoMode = 1;
+  }
+
+  switch((AACENC_BITRATE_MODE)bitrateMode){
+  case AACENC_BR_MODE_VBR_1:
+  case AACENC_BR_MODE_VBR_2:
+  case AACENC_BR_MODE_VBR_3:
+  case AACENC_BR_MODE_VBR_4:
+  case AACENC_BR_MODE_VBR_5:
+    bitrate = configTabVBR[bitrateMode].chanBitrate[monoStereoMode];
+    break;
+  case AACENC_BR_MODE_INVALID:
+  case AACENC_BR_MODE_CBR:
+  case AACENC_BR_MODE_SFR:
+  case AACENC_BR_MODE_FF:
+  default:
+    bitrate = 0;
+    break;
+  }
+
+  /* convert channel bitrate to overall bitrate*/
+  bitrate *= FDKaacEnc_GetChannelModeConfiguration(channelMode)->nChannelsEff;
+
+  return bitrate;
+}
+
+/**
+ * \brief  Convert encoder bitreservoir value for transport library.
+ *
+ * \param bitrateMode           Bitratemode used in current encoder instance. Se ::AACENC_BITRATE_MODE
+ * \param bitresTotal           Encoder bitreservoir level in bits.
+ *
+ * \return  Corrected bitreservoir level used in transport library.
+ */
+static INT FDKaacEnc_EncBitresToTpBitres(
+        const AACENC_BITRATE_MODE bitrateMode,
+        const INT                 bitresTotal
+        )
+{
+  INT transporBitreservoir = 0;
+
+  switch (bitrateMode) {
+    case AACENC_BR_MODE_CBR:
+      transporBitreservoir = bitresTotal; /* encoder bitreservoir level */
+      break;
+    case AACENC_BR_MODE_VBR_1:
+    case AACENC_BR_MODE_VBR_2:
+    case AACENC_BR_MODE_VBR_3:
+    case AACENC_BR_MODE_VBR_4:
+    case AACENC_BR_MODE_VBR_5:
+      transporBitreservoir = FDK_INT_MAX; /* signal variable bitrate */
+      break;
+    case AACENC_BR_MODE_FF:
+    case AACENC_BR_MODE_SFR:
+      transporBitreservoir = 0;           /* super framing and fixed framing */
+      break;                              /* without bitreservoir signaling */
+    default:
+    case AACENC_BR_MODE_INVALID:
+      transporBitreservoir = 0;           /* invalid configuration*/
+      FDK_ASSERT(0);
+  }
+
+  return transporBitreservoir;
+}
+
+/*-----------------------------------------------------------------------------
+
+     functionname: FDKaacEnc_AacInitDefaultConfig
+     description:  gives reasonable default configuration
+     returns:      ---
+
+ ------------------------------------------------------------------------------*/
+void FDKaacEnc_AacInitDefaultConfig(AACENC_CONFIG *config)
+{
+    /* make thepre initialization of the structs flexible */
+    FDKmemclear(config, sizeof(AACENC_CONFIG));
+
+    /* default ancillary */
+    config->anc_Rate = 0;         /* no ancillary data */
+    config->ancDataBitRate = 0;   /* no additional consumed bitrate */
+
+    /* default configurations */
+    config->bitRate         = -1;                   /* bitrate must be set*/
+    config->averageBits     = -1;                   /* instead of bitrate/s we can configure bits/superframe */
+    config->bitrateMode     = 0;
+    config->bandWidth       = 0;                    /* get bandwidth from table */
+    config->useTns          = TNS_ENABLE_MASK;      /* tns enabled completly */
+    config->usePns          = 1;                    /* depending on channelBitrate this might be set to 0 later */
+    config->useIS           = 1;                    /* Intensity Stereo Configuration */
+    config->framelength     = DEFAULT_FRAMELENGTH;  /* used frame size */
+    config->syntaxFlags     = 0;                    /* default syntax with no specialities */
+    config->epConfig        = -1;                   /* no ER syntax -> no additional error protection */
+    config->nSubFrames      = 1;                    /* default, no sub frames */
+    config->channelOrder    = CH_ORDER_MPEG;        /* Use MPEG channel ordering. */
+    config->channelMode     = MODE_UNKNOWN;
+    config->minBitsPerFrame = -1;                   /* minum number of bits in each AU */
+    config->maxBitsPerFrame = -1;                   /* minum number of bits in each AU */
+    config->bitreservoir    = -1;                   /* default, uninitialized value */
+
+    /* init tabs in fixpoint_math */
+    InitLdInt();
+    InitInvSqrtTab();
+}
+
+
+/*---------------------------------------------------------------------------
+
+    functionname: FDKaacEnc_Open
+    description:  allocate and initialize a new encoder instance
+    returns:      error code
+
+  ---------------------------------------------------------------------------*/
+AAC_ENCODER_ERROR FDKaacEnc_Open(HANDLE_AAC_ENC  *phAacEnc,
+                                 const INT        nElements,
+                                 const INT        nChannels,
+                                 const INT        nSubFrames)
+{
+  AAC_ENCODER_ERROR ErrorStatus;
+  AAC_ENC           *hAacEnc = NULL;
+  UCHAR             *dynamicRAM = NULL;
+
+  if (phAacEnc==NULL) {
+    return AAC_ENC_INVALID_HANDLE;
+  }
+
+  /* allocate encoder structure */
+  hAacEnc = GetRam_aacEnc_AacEncoder();
+  if (hAacEnc == NULL) {
+    ErrorStatus = AAC_ENC_NO_MEMORY;
+    goto bail;
+  }
+  FDKmemclear(hAacEnc, sizeof(AAC_ENC));
+
+  hAacEnc->dynamic_RAM = GetAACdynamic_RAM();
+  dynamicRAM = (UCHAR*)hAacEnc->dynamic_RAM;
+
+  /* allocate the Psy aud Psy Out structure */
+   ErrorStatus = FDKaacEnc_PsyNew(&hAacEnc->psyKernel,
+                                  nElements,
+                                  nChannels
+                                 ,dynamicRAM
+                                 );
+   if (ErrorStatus != AAC_ENC_OK)
+     goto bail;
+
+   ErrorStatus = FDKaacEnc_PsyOutNew(hAacEnc->psyOut,
+                                     nElements,
+                                     nChannels,
+                                     nSubFrames
+                                    ,dynamicRAM
+                                    );
+   if (ErrorStatus != AAC_ENC_OK)
+     goto bail;
+
+  /* allocate the Q&C Out structure */
+  ErrorStatus = FDKaacEnc_QCOutNew(hAacEnc->qcOut,
+                                   nElements,
+                                   nChannels,
+                                   nSubFrames
+                                  ,dynamicRAM
+                                   );
+  if (ErrorStatus != AAC_ENC_OK)
+    goto bail;
+
+  /* allocate the Q&C kernel */
+  ErrorStatus = FDKaacEnc_QCNew(&hAacEnc->qcKernel,
+                                 nElements
+                                ,dynamicRAM
+                                );
+  if (ErrorStatus != AAC_ENC_OK)
+    goto bail;
+
+  hAacEnc->maxChannels = nChannels;
+  hAacEnc->maxElements = nElements;
+  hAacEnc->maxFrames   = nSubFrames;
+
+bail:
+  *phAacEnc = hAacEnc;
+  return ErrorStatus;
+}
+
+
+AAC_ENCODER_ERROR FDKaacEnc_Initialize(HANDLE_AAC_ENC      hAacEnc,
+                                       AACENC_CONFIG      *config,     /* pre-initialized config struct */
+                                       HANDLE_TRANSPORTENC hTpEnc,
+                                       ULONG               initFlags)
+{
+  AAC_ENCODER_ERROR ErrorStatus;
+  INT psyBitrate, tnsMask; //INT profile = 1;
+  CHANNEL_MAPPING   *cm = NULL;
+
+  INT qmbfac, qbw;
+  FIXP_DBL mbfac, bw_ratio;
+  QC_INIT qcInit;
+  INT averageBitsPerFrame = 0;
+
+  if (config==NULL)
+    return AAC_ENC_INVALID_HANDLE;
+
+  /******************* sanity checks *******************/
+
+  /* check config structure */
+  if (config->nChannels  < 1 || config->nChannels > (6)) {
+    return AAC_ENC_UNSUPPORTED_CHANNELCONFIG;
+  }
+
+  /* check sample rate */
+  switch (config->sampleRate)
+  {
+    case 8000:
+    case 11025:
+    case 12000:
+    case 16000:
+    case 22050:
+    case 24000:
+    case 32000:
+    case 44100:
+    case 48000:
+    case 64000:
+    case 88200:
+    case 96000:
+      break;
+    default:
+      return AAC_ENC_UNSUPPORTED_SAMPLINGRATE;
+  }
+
+  /* bitrate has to be set */
+  if (config->bitRate==-1) {
+      return AAC_ENC_UNSUPPORTED_BITRATE;
+  }
+
+  /* check bit rate */
+
+  /* check if bitRate is not too low or high */
+    averageBitsPerFrame = (config->bitRate*(config->framelength>>GetSrSf(config->sampleRate))) / (config->sampleRate>>GetSrSf(config->sampleRate)) / config->nSubFrames;
+
+  /* assume minimum static bits of 40 in each channel. */
+  if ( (averageBitsPerFrame <= ((40*config->nChannels) + transportEnc_GetStaticBits(hTpEnc, averageBitsPerFrame))) ||
+       ( ((config->bitRate*(config->framelength>>GetSrSf(config->sampleRate)))) >
+         ((FDKaacEnc_GetChannelModeConfiguration(config->channelMode)->nChannelsEff * MIN_BUFSIZE_PER_EFF_CHAN))*(config->sampleRate>>GetSrSf(config->sampleRate)) )
+     )
+  {
+      return AAC_ENC_UNSUPPORTED_BITRATE;
+  }
+
+  if (config->syntaxFlags & AC_ER_VCB11) {
+      return AAC_ENC_UNSUPPORTED_ER_FORMAT;
+  }
+  if (config->syntaxFlags & AC_ER_HCR) {
+      return AAC_ENC_UNSUPPORTED_ER_FORMAT;
+  }
+
+  /* check frame length */
+  switch (config->framelength)
+  {
+    case 1024:
+      if ( config->audioObjectType != AOT_AAC_LC
+        && config->audioObjectType != AOT_SBR
+        && config->audioObjectType != AOT_PS
+        && config->audioObjectType != AOT_ER_AAC_LC
+        && config->audioObjectType != AOT_AAC_SCAL )
+      {
+        return AAC_ENC_INVALID_FRAME_LENGTH;
+      }
+      break;
+    case 512:
+    case 480:
+      if ( config->audioObjectType != AOT_ER_AAC_LD
+        && config->audioObjectType != AOT_ER_AAC_ELD )
+      {
+        return AAC_ENC_INVALID_FRAME_LENGTH;
+      }
+      break;
+    default:
+      return AAC_ENC_INVALID_FRAME_LENGTH;
+  }
+
+  if (config->anc_Rate != 0) {
+
+     ErrorStatus = FDKaacEnc_InitCheckAncillary(config->bitRate,
+                                                config->framelength,
+                                                config->anc_Rate,
+                                               &hAacEnc->ancillaryBitsPerFrame,
+                                                config->sampleRate);
+     if (ErrorStatus != AAC_ENC_OK)
+       goto bail;
+
+
+     /* update estimated consumed bitrate */
+     config->ancDataBitRate += ( (hAacEnc->ancillaryBitsPerFrame * config->sampleRate) / config->framelength );
+
+  }
+
+  /* maximal allowed DSE bytes in frame */
+  {
+  /* fixpoint calculation*/
+  INT q_res, encBitrate, sc;
+  FIXP_DBL tmp = fDivNorm(config->framelength, config->sampleRate, &q_res);
+  encBitrate = (config->bitRate/*-config->ancDataBitRate*/)- (INT)(config->nChannels*8000);
+  sc = CountLeadingBits(encBitrate);
+  config->maxAncBytesPerAU = FDKmin( (256), FDKmax(0,(INT)(fMultDiv2(tmp, (FIXP_DBL)(encBitrate<<sc))>>(-q_res+sc-1+3))) );
+  }
+
+  /* bind config to hAacEnc->config */
+  hAacEnc->config = config;
+
+  /* set hAacEnc->bitrateMode */
+  hAacEnc->bitrateMode = (AACENC_BITRATE_MODE)config->bitrateMode;
+
+  hAacEnc->encoderMode = config->channelMode;
+
+  ErrorStatus = FDKaacEnc_InitChannelMapping(hAacEnc->encoderMode, config->channelOrder, &hAacEnc->channelMapping);
+  if (ErrorStatus != AAC_ENC_OK)
+    goto bail;
+
+  cm = &hAacEnc->channelMapping;
+
+  ErrorStatus = FDKaacEnc_DetermineBandWidth(&hAacEnc->config->bandWidth,
+                                             config->bandWidth,
+                                             config->bitRate - config->ancDataBitRate,
+                                             hAacEnc->bitrateMode,
+                                             config->sampleRate,
+                                             config->framelength,
+                                             cm,
+                                             hAacEnc->encoderMode);
+  if (ErrorStatus != AAC_ENC_OK)
+    goto bail;
+
+  hAacEnc->bandwidth90dB = (INT)hAacEnc->config->bandWidth;
+
+  tnsMask = config->useTns ? TNS_ENABLE_MASK : 0x0;
+  psyBitrate = config->bitRate - config->ancDataBitRate;
+
+  ErrorStatus = FDKaacEnc_psyInit(hAacEnc->psyKernel,
+                                  hAacEnc->psyOut,
+                                  hAacEnc->maxFrames,
+                                  hAacEnc->maxChannels,
+                                  config->audioObjectType,
+                                  cm);
+  if (ErrorStatus != AAC_ENC_OK)
+    goto bail;
+
+  ErrorStatus = FDKaacEnc_psyMainInit(hAacEnc->psyKernel,
+                                      config->audioObjectType,
+                                      cm,
+                                      config->sampleRate,
+                                      config->framelength,
+                                      psyBitrate,
+                                      tnsMask,
+                                      hAacEnc->bandwidth90dB,
+                                      config->usePns,
+                                      config->useIS,
+                                      config->syntaxFlags,
+                                      initFlags);
+  if (ErrorStatus != AAC_ENC_OK)
+    goto bail;
+
+  ErrorStatus = FDKaacEnc_QCOutInit(hAacEnc->qcOut, hAacEnc->maxFrames, cm);
+  if (ErrorStatus != AAC_ENC_OK)
+    goto bail;
+
+
+
+  qcInit.channelMapping      = &hAacEnc->channelMapping;
+  qcInit.sceCpe              = 0;
+
+  {
+      int maxBitres;
+      qcInit.averageBits     = (averageBitsPerFrame+7)&~7;
+      maxBitres              = (MIN_BUFSIZE_PER_EFF_CHAN*cm->nChannelsEff) - qcInit.averageBits;
+      qcInit.bitRes          = (config->bitreservoir!=-1) ? FDKmin(config->bitreservoir, maxBitres) : maxBitres;
+
+      qcInit.maxBits         = fixMin(MIN_BUFSIZE_PER_EFF_CHAN*cm->nChannelsEff, ((averageBitsPerFrame+7)&~7)+qcInit.bitRes);
+      qcInit.maxBits         = (config->maxBitsPerFrame!=-1) ? fixMin(qcInit.maxBits, config->maxBitsPerFrame) : qcInit.maxBits;
+
+      qcInit.minBits         = fixMax(0, ((averageBitsPerFrame-1)&~7)-qcInit.bitRes-transportEnc_GetStaticBits(hTpEnc, ((averageBitsPerFrame+7)&~7)+qcInit.bitRes));
+      qcInit.minBits         = (config->minBitsPerFrame!=-1) ? fixMax(qcInit.minBits, config->minBitsPerFrame) : qcInit.minBits;
+  }
+
+  qcInit.nSubFrames          = config->nSubFrames;
+  qcInit.padding.paddingRest = config->sampleRate;
+
+  /* Calc meanPe */
+  bw_ratio = fDivNorm((FIXP_DBL)hAacEnc->bandwidth90dB, (FIXP_DBL)(config->sampleRate>>1), &qbw);
+  qbw = DFRACT_BITS-1-qbw;
+  /* qcInit.meanPe = 10.0f * FRAME_LEN_LONG * hAacEnc->bandwidth90dB/(config->sampleRate/2.0f); */
+  qcInit.meanPe = fMult(bw_ratio, (FIXP_DBL)((10*config->framelength)<<16)) >> (qbw-15);
+
+  /* Calc maxBitFac */
+  mbfac = fDivNorm((MIN_BUFSIZE_PER_EFF_CHAN-744)*cm->nChannelsEff, qcInit.averageBits/qcInit.nSubFrames, &qmbfac);
+  qmbfac = DFRACT_BITS-1-qmbfac;
+  qcInit.maxBitFac = (qmbfac > 24) ? (mbfac >> (qmbfac - 24)):(mbfac << (24 - qmbfac));
+
+  switch(config->bitrateMode){
+  case AACENC_BR_MODE_CBR:
+    qcInit.bitrateMode = QCDATA_BR_MODE_CBR;
+    break;
+  case AACENC_BR_MODE_VBR_1:
+    qcInit.bitrateMode = QCDATA_BR_MODE_VBR_1;
+    break;
+  case AACENC_BR_MODE_VBR_2:
+    qcInit.bitrateMode = QCDATA_BR_MODE_VBR_2;
+    break;
+  case AACENC_BR_MODE_VBR_3:
+    qcInit.bitrateMode = QCDATA_BR_MODE_VBR_3;
+    break;
+  case AACENC_BR_MODE_VBR_4:
+    qcInit.bitrateMode = QCDATA_BR_MODE_VBR_4;
+    break;
+  case AACENC_BR_MODE_VBR_5:
+    qcInit.bitrateMode = QCDATA_BR_MODE_VBR_5;
+    break;
+  case AACENC_BR_MODE_SFR:
+    qcInit.bitrateMode = QCDATA_BR_MODE_SFR;
+    break;
+  case AACENC_BR_MODE_FF:
+    qcInit.bitrateMode = QCDATA_BR_MODE_FF;
+    break;
+  default:
+    ErrorStatus = AAC_ENC_UNSUPPORTED_BITRATE_MODE;
+    goto bail;
+  }
+
+  qcInit.invQuant = (config->useRequant)?2:0;
+
+  /* maxIterations should be set to the maximum number of requantization iterations that are
+   * allowed before the crash recovery functionality is activated. This setting should be adjusted
+   * to the processing power available, i.e. to the processing power headroom in one frame that is
+   * still left after normal encoding without requantization. Please note that if activated this
+   * functionality is used most likely only in cases where the encoder is operating beyond
+   * recommended settings, i.e. the audio quality is suboptimal anyway. Activating the crash
+   * recovery does not further reduce audio quality significantly in these cases. */
+  if ( (config->audioObjectType == AOT_ER_AAC_LD) || (config->audioObjectType == AOT_ER_AAC_ELD) ) {
+    qcInit.maxIterations = 2;
+  }
+  else
+  {
+    qcInit.maxIterations = 5;
+  }
+
+  qcInit.bitrate = config->bitRate - config->ancDataBitRate;
+
+  qcInit.staticBits = transportEnc_GetStaticBits(hTpEnc, qcInit.averageBits/qcInit.nSubFrames);
+
+  ErrorStatus = FDKaacEnc_QCInit(hAacEnc->qcKernel, &qcInit);
+  if (ErrorStatus != AAC_ENC_OK)
+    goto bail;
+
+  /* Map virtual aot's to intern aot used in bitstream writer. */
+  switch (hAacEnc->config->audioObjectType) {
+    case AOT_MP2_AAC_LC:
+    case AOT_DABPLUS_AAC_LC:
+      hAacEnc->aot = AOT_AAC_LC;
+      break;
+    case AOT_MP2_SBR:
+    case AOT_DABPLUS_SBR:
+      hAacEnc->aot = AOT_SBR;
+      break;
+    case AOT_MP2_PS:
+    case AOT_DABPLUS_PS:
+      hAacEnc->aot = AOT_PS;
+      break;
+    default:
+      hAacEnc->aot = hAacEnc->config->audioObjectType;
+  }
+
+  /* common things */
+
+  return AAC_ENC_OK;
+
+bail:
+
+  return ErrorStatus;
+}
+
+
+/*---------------------------------------------------------------------------
+
+    functionname: FDKaacEnc_EncodeFrame
+    description:  encodes one frame
+    returns:      error code
+
+  ---------------------------------------------------------------------------*/
+AAC_ENCODER_ERROR FDKaacEnc_EncodeFrame( HANDLE_AAC_ENC       hAacEnc,          /* encoder handle */
+                                         HANDLE_TRANSPORTENC  hTpEnc,
+                                         INT_PCM* RESTRICT    inputBuffer,
+                                         INT*                 nOutBytes,
+                                         AACENC_EXT_PAYLOAD   extPayload[MAX_TOTAL_EXT_PAYLOADS]
+                                       )
+{
+    AAC_ENCODER_ERROR ErrorStatus;
+    int    el, n, c=0;
+    UCHAR  extPayloadUsed[MAX_TOTAL_EXT_PAYLOADS];
+
+    CHANNEL_MAPPING *cm      = &hAacEnc->channelMapping;
+
+
+
+    PSY_OUT *psyOut = hAacEnc->psyOut[c];
+    QC_OUT  *qcOut  = hAacEnc->qcOut[c];
+
+    FDKmemclear(extPayloadUsed, MAX_TOTAL_EXT_PAYLOADS * sizeof(UCHAR));
+
+    qcOut->elementExtBits = 0; /* sum up all extended bit of each element */
+    qcOut->staticBits     = 0; /* sum up side info bits of each element */
+    qcOut->totalNoRedPe   = 0; /* sum up PE */
+
+    /* advance psychoacoustics */
+    for (el=0; el<cm->nElements; el++) {
+        ELEMENT_INFO elInfo = cm->elInfo[el];
+
+        if ( (elInfo.elType == ID_SCE)
+          || (elInfo.elType == ID_CPE)
+          || (elInfo.elType == ID_LFE) )
+        {
+            int ch;
+
+            /* update pointer!*/
+            for(ch=0;ch<elInfo.nChannelsInEl;ch++) {
+                PSY_OUT_CHANNEL *psyOutChan = psyOut->psyOutElement[el]->psyOutChannel[ch];
+                QC_OUT_CHANNEL  *qcOutChan = qcOut->qcElement[el]->qcOutChannel[ch];
+
+                psyOutChan->mdctSpectrum       = qcOutChan->mdctSpectrum;
+                psyOutChan->sfbSpreadEnergy  = qcOutChan->sfbSpreadEnergy;
+                psyOutChan->sfbEnergy          = qcOutChan->sfbEnergy;
+                psyOutChan->sfbEnergyLdData    = qcOutChan->sfbEnergyLdData;
+                psyOutChan->sfbMinSnrLdData    = qcOutChan->sfbMinSnrLdData;
+                psyOutChan->sfbThresholdLdData = qcOutChan->sfbThresholdLdData;
+
+            }
+
+            FDKaacEnc_psyMain(elInfo.nChannelsInEl,
+                              hAacEnc->psyKernel->psyElement[el],
+                              hAacEnc->psyKernel->psyDynamic,
+                              hAacEnc->psyKernel->psyConf,
+                              psyOut->psyOutElement[el],
+                              inputBuffer,
+                              cm->elInfo[el].ChannelIndex,
+                              cm->nChannels
+
+                    );
+
+            /* FormFactor, Pe and staticBitDemand calculation */
+            ErrorStatus = FDKaacEnc_QCMainPrepare(&elInfo,
+                                                   hAacEnc->qcKernel->hAdjThr->adjThrStateElem[el],
+                                                   psyOut->psyOutElement[el],
+                                                   qcOut->qcElement[el],
+                                                   hAacEnc->aot,
+                                                   hAacEnc->config->syntaxFlags,
+                                                   hAacEnc->config->epConfig);
+
+            if (ErrorStatus != AAC_ENC_OK)
+              return ErrorStatus;
+
+            /*-------------------------------------------- */
+
+            qcOut->qcElement[el]->extBitsUsed = 0;
+            qcOut->qcElement[el]->nExtensions = 0;
+            /* reset extension payload */
+            FDKmemclear(&qcOut->qcElement[el]->extension, (1)*sizeof(QC_OUT_EXTENSION));
+
+            for ( n = 0; n < MAX_TOTAL_EXT_PAYLOADS; n++ ) {
+                if ( !extPayloadUsed[n]
+                  && (extPayload[n].associatedChElement == el)
+                  && (extPayload[n].dataSize > 0)
+                  && (extPayload[n].pData != NULL) )
+                {
+                    int idx = qcOut->qcElement[el]->nExtensions++;
+
+                    qcOut->qcElement[el]->extension[idx].type         = extPayload[n].dataType;   /* Perform a sanity check on the type? */
+                    qcOut->qcElement[el]->extension[idx].nPayloadBits = extPayload[n].dataSize;
+                    qcOut->qcElement[el]->extension[idx].pPayload = extPayload[n].pData;
+                    /* Now ask the bitstream encoder how many bits we need to encode the data with the current bitstream syntax: */
+                    qcOut->qcElement[el]->extBitsUsed +=
+                          FDKaacEnc_writeExtensionData( NULL,
+                                                       &qcOut->qcElement[el]->extension[idx],
+                                                        0, 0,
+                                                        hAacEnc->config->syntaxFlags,
+                                                        hAacEnc->aot,
+                                                        hAacEnc->config->epConfig );
+                    extPayloadUsed[n] = 1;
+                }
+            }
+
+            /* sum up extension and static bits for all channel elements */
+            qcOut->elementExtBits += qcOut->qcElement[el]->extBitsUsed;
+            qcOut->staticBits   += qcOut->qcElement[el]->staticBitsUsed;
+
+            /* sum up pe */
+            qcOut->totalNoRedPe += qcOut->qcElement[el]->peData.pe;
+        }
+    }
+
+    qcOut->nExtensions   = 0;
+    qcOut->globalExtBits = 0;
+
+    /* reset extension payload */
+    FDKmemclear(&qcOut->extension, (2+2)*sizeof(QC_OUT_EXTENSION));
+
+    /* Add extension payload not assigned to an channel element
+      (Ancillary data is the only supported type up to now) */
+    for ( n = 0; n < MAX_TOTAL_EXT_PAYLOADS; n++ ) {
+        if ( !extPayloadUsed[n]
+          && (extPayload[n].associatedChElement == -1)
+          && (extPayload[n].pData != NULL) )
+        {
+            UINT payloadBits = 0;
+
+            if (extPayload[n].dataType == EXT_DATA_ELEMENT) {
+                if (hAacEnc->ancillaryBitsPerFrame) {
+                    /* granted frame dse bitrate */
+                    payloadBits = hAacEnc->ancillaryBitsPerFrame;
+                }
+                else {
+                    /* write anc data if bitrate constraint fulfilled */
+                    if ((extPayload[n].dataSize>>3) <= hAacEnc->config->maxAncBytesPerAU) {
+                        payloadBits = extPayload[n].dataSize;
+                    }
+                }
+                payloadBits = fixMin( extPayload[n].dataSize, payloadBits );
+            } else {
+                payloadBits = extPayload[n].dataSize;
+            }
+
+            if (payloadBits > 0)
+            {
+                int idx = qcOut->nExtensions++;
+
+                qcOut->extension[idx].type         = extPayload[n].dataType;   /* Perform a sanity check on the type? */
+                qcOut->extension[idx].nPayloadBits = payloadBits;
+                qcOut->extension[idx].pPayload = extPayload[n].pData;
+                /* Now ask the bitstream encoder how many bits we need to encode the data with the current bitstream syntax: */
+                qcOut->globalExtBits += FDKaacEnc_writeExtensionData( NULL,
+                                                                     &qcOut->extension[idx],
+                                                                      0, 0,
+                                                                      hAacEnc->config->syntaxFlags,
+                                                                      hAacEnc->aot,
+                                                                      hAacEnc->config->epConfig );
+                if (extPayload[n].dataType == EXT_DATA_ELEMENT) {
+                    /* substract the processed bits */
+                    extPayload[n].dataSize -= payloadBits;
+                }
+                extPayloadUsed[n] = 1;
+            }
+        }
+    }
+
+    if (!(hAacEnc->config->syntaxFlags & (AC_SCALABLE|AC_ER))) {
+      qcOut->globalExtBits += EL_ID_BITS;  /* add bits for ID_END */
+    }
+
+    /* build bitstream all nSubFrames */
+    {
+        INT totalBits    = 0;   /* Total AU bits */;
+        INT avgTotalBits = 0;
+
+        /*-------------------------------------------- */
+        /* Get average total bits */
+        /*-------------------------------------------- */
+        {
+            /* frame wise bitrate adaption */
+            FDKaacEnc_AdjustBitrate(hAacEnc->qcKernel,
+                                    cm,
+                                   &avgTotalBits,
+                                    hAacEnc->config->bitRate,
+                                    hAacEnc->config->sampleRate,
+                                    hAacEnc->config->framelength);
+
+            /* adjust super frame bitrate */
+            avgTotalBits *= hAacEnc->config->nSubFrames;
+        }
+
+        /* Make first estimate of transport header overhead.
+           Take maximum possible frame size into account to prevent bitreservoir underrun. */
+        hAacEnc->qcKernel->globHdrBits = transportEnc_GetStaticBits(hTpEnc, avgTotalBits + hAacEnc->qcKernel->bitResTot);
+
+
+        /*-------------------------------------------- */
+        /*-------------------------------------------- */
+        /*-------------------------------------------- */
+
+        ErrorStatus = FDKaacEnc_QCMain(hAacEnc->qcKernel,
+                                       hAacEnc->psyOut,
+                                       hAacEnc->qcOut,
+                                       avgTotalBits,
+                                       cm
+                                      ,hAacEnc->aot,
+                                       hAacEnc->config->syntaxFlags,
+                                       hAacEnc->config->epConfig);
+
+        if (ErrorStatus != AAC_ENC_OK)
+            return ErrorStatus;
+        /*-------------------------------------------- */
+
+        /*-------------------------------------------- */
+        ErrorStatus = FDKaacEnc_updateFillBits(cm,
+                                               hAacEnc->qcKernel,
+                                               hAacEnc->qcKernel->elementBits,
+                                               hAacEnc->qcOut);
+        if (ErrorStatus != AAC_ENC_OK)
+            return ErrorStatus;
+
+            /*-------------------------------------------- */
+            ErrorStatus = FDKaacEnc_FinalizeBitConsumption(cm,
+                                                           hAacEnc->qcKernel,
+                                                           qcOut,
+                                                           qcOut->qcElement,
+                                                           hTpEnc,
+                                                           hAacEnc->aot,
+                                                           hAacEnc->config->syntaxFlags,
+                                                           hAacEnc->config->epConfig);
+            if (ErrorStatus != AAC_ENC_OK)
+                return ErrorStatus;
+            /*-------------------------------------------- */
+            totalBits += qcOut->totalBits;
+
+
+        /*-------------------------------------------- */
+        FDKaacEnc_updateBitres(cm,
+                               hAacEnc->qcKernel,
+                               hAacEnc->qcOut);
+
+        /*-------------------------------------------- */
+
+        /* for ( all sub frames ) ... */
+              /* write bitstream header */
+              transportEnc_WriteAccessUnit(
+                    hTpEnc,
+                    totalBits,
+                    FDKaacEnc_EncBitresToTpBitres(hAacEnc->bitrateMode, hAacEnc->qcKernel->bitResTot),
+                    cm->nChannelsEff);
+
+              /* write bitstream */
+              ErrorStatus = FDKaacEnc_WriteBitstream(
+                    hTpEnc,
+                    cm,
+                    qcOut,
+                    psyOut,
+                    hAacEnc->qcKernel,
+                    hAacEnc->aot,
+                    hAacEnc->config->syntaxFlags,
+                    hAacEnc->config->epConfig);
+
+              if (ErrorStatus != AAC_ENC_OK)
+                return ErrorStatus;
+
+              /* transportEnc_EndAccessUnit() is being called inside FDKaacEnc_WriteBitstream() */
+              transportEnc_GetFrame(hTpEnc, nOutBytes);
+
+    } /* -end- if (curFrame==hAacEnc->qcKernel->nSubFrames) */
+
+
+    /*-------------------------------------------- */
+    return AAC_ENC_OK;
+}
+
+/*---------------------------------------------------------------------------
+
+    functionname:FDKaacEnc_Close
+    description: delete encoder instance
+    returns:
+
+  ---------------------------------------------------------------------------*/
+
+void FDKaacEnc_Close( HANDLE_AAC_ENC*  phAacEnc)   /* encoder handle */
+{
+    if (*phAacEnc == NULL) {
+      return;
+    }
+    AAC_ENC *hAacEnc = (AAC_ENC*)*phAacEnc;
+
+   if (hAacEnc->dynamic_RAM != NULL)
+       FreeAACdynamic_RAM(&hAacEnc->dynamic_RAM);
+
+    FDKaacEnc_PsyClose(&hAacEnc->psyKernel,hAacEnc->psyOut);
+
+    FDKaacEnc_QCClose(&hAacEnc->qcKernel, hAacEnc->qcOut);
+
+    FreeRam_aacEnc_AacEncoder(phAacEnc);
+}
+
+
+/* The following functions are in this source file only for convenience and */
+/* need not be visible outside of a possible encoder library. */
+
+/* basic defines for ancillary data */
+#define MAX_ANCRATE 19200            /* ancillary rate >= 19200 isn't valid */
+
+/*---------------------------------------------------------------------------
+
+    functionname:  FDKaacEnc_InitCheckAncillary
+    description:   initialize and check ancillary data struct
+    return:        if success or NULL if error
+
+  ---------------------------------------------------------------------------*/
+static AAC_ENCODER_ERROR FDKaacEnc_InitCheckAncillary(INT bitRate,
+                                                      INT framelength,
+                                                      INT ancillaryRate,
+                                                      INT *ancillaryBitsPerFrame,
+                                                      INT sampleRate)
+{
+  INT diffToByteAlign;
+
+  /* don't use negative ancillary rates */
+  if ( ancillaryRate < -1 )
+    return AAC_ENC_UNSUPPORTED_ANC_BITRATE;
+
+  /* check if ancillary rate is ok */
+  if ( (ancillaryRate != (-1)) && (ancillaryRate != 0) ) {
+    /* ancRate <= 15% of bitrate && ancRate < 19200 */
+    if ( ( ancillaryRate >= MAX_ANCRATE ) ||
+         ( (ancillaryRate * 20) > (bitRate * 3) ) ) {
+      return AAC_ENC_UNSUPPORTED_ANC_BITRATE;
+    }
+  }
+  else if (ancillaryRate == -1) {
+    /* if no special ancRate is requested but a ancillary file is
+       stated, then generate a ancillary rate matching to the bitrate */
+    if (bitRate >= (MAX_ANCRATE * 10)) {
+      /* ancillary rate is 19199 */
+      ancillaryRate = (MAX_ANCRATE - 1);
+    }
+    else { /* 10% of bitrate */
+      ancillaryRate = bitRate / 10;
+    }
+  }
+
+  /* make ancillaryBitsPerFrame byte align */
+  *ancillaryBitsPerFrame = (ancillaryRate * framelength ) / sampleRate;
+  diffToByteAlign = *ancillaryBitsPerFrame % 8;
+  *ancillaryBitsPerFrame = *ancillaryBitsPerFrame - diffToByteAlign;
+
+  return AAC_ENC_OK;
+}