/* -----------------------------------------------------------------------------
Software License for The Fraunhofer FDK AAC Codec Library for Android

© Copyright  1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten
Forschung e.V. All rights reserved.

 1.    INTRODUCTION
The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software
that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding
scheme for digital audio. This FDK AAC Codec software is intended to be used on
a wide variety of Android devices.

AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient
general perceptual audio codecs. AAC-ELD is considered the best-performing
full-bandwidth communications codec by independent studies and is widely
deployed. AAC has been standardized by ISO and IEC as part of the MPEG
specifications.

Patent licenses for necessary patent claims for the FDK AAC Codec (including
those of Fraunhofer) may be obtained through Via Licensing
(www.vialicensing.com) or through the respective patent owners individually for
the purpose of encoding or decoding bit streams in products that are compliant
with the ISO/IEC MPEG audio standards. Please note that most manufacturers of
Android devices already license these patent claims through Via Licensing or
directly from the patent owners, and therefore FDK AAC Codec software may
already be covered under those patent licenses when it is used for those
licensed purposes only.

Commercially-licensed AAC software libraries, including floating-point versions
with enhanced sound quality, are also available from Fraunhofer. Users are
encouraged to check the Fraunhofer website for additional applications
information and documentation.

2.    COPYRIGHT LICENSE

Redistribution and use in source and binary forms, with or without modification,
are permitted without payment of copyright license fees provided that you
satisfy the following conditions:

You must retain the complete text of this software license in redistributions of
the FDK AAC Codec or your modifications thereto in source code form.

You must retain the complete text of this software license in the documentation
and/or other materials provided with redistributions of the FDK AAC Codec or
your modifications thereto in binary form. You must make available free of
charge copies of the complete source code of the FDK AAC Codec and your
modifications thereto to recipients of copies in binary form.

The name of Fraunhofer may not be used to endorse or promote products derived
from this library without prior written permission.

You may not charge copyright license fees for anyone to use, copy or distribute
the FDK AAC Codec software or your modifications thereto.

Your modified versions of the FDK AAC Codec must carry prominent notices stating
that you changed the software and the date of any change. For modified versions
of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android"
must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK
AAC Codec Library for Android."

3.    NO PATENT LICENSE

NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without
limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE.
Fraunhofer provides no warranty of patent non-infringement with respect to this
software.

You may use this FDK AAC Codec software or modifications thereto only for
purposes that are authorized by appropriate patent licenses.

4.    DISCLAIMER

This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright
holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
including but not limited to the implied warranties of merchantability and
fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary,
or consequential damages, including but not limited to procurement of substitute
goods or services; loss of use, data, or profits, or business interruption,
however caused and on any theory of liability, whether in contract, strict
liability, or tort (including negligence), arising in any way out of the use of
this software, even if advised of the possibility of such damage.

5.    CONTACT INFORMATION

Fraunhofer Institute for Integrated Circuits IIS
Attention: Audio and Multimedia Departments - FDK AAC LL
Am Wolfsmantel 33
91058 Erlangen, Germany

www.iis.fraunhofer.de/amm
amm-info@iis.fraunhofer.de
----------------------------------------------------------------------------- */

/**************************** AAC encoder library ******************************

   Author(s):   V. Bacigalupo

   Description: Metadata Encoder library interface functions

*******************************************************************************/

#include "metadata_main.h"
#include "metadata_compressor.h"
#include "FDK_bitstream.h"
#include "FDK_audio.h"
#include "genericStds.h"

/*----------------- defines ----------------------*/
#define MAX_DRC_BANDS (1 << 4)
#define MAX_DRC_FRAMELEN (2 * 1024)
#define MAX_DELAY_FRAMES (3)

/*--------------- structure definitions --------------------*/

typedef struct AAC_METADATA {
  /* MPEG: Dynamic Range Control */
  struct {
    UCHAR prog_ref_level_present;
    SCHAR prog_ref_level;

    UCHAR dyn_rng_sgn[MAX_DRC_BANDS];
    UCHAR dyn_rng_ctl[MAX_DRC_BANDS];

    UCHAR drc_bands_present;
    UCHAR drc_band_incr;
    UCHAR drc_band_top[MAX_DRC_BANDS];
    UCHAR drc_interpolation_scheme;
    AACENC_METADATA_DRC_PROFILE drc_profile;
    INT drc_TargetRefLevel; /* used for Limiter */

    /* excluded channels */
    UCHAR excluded_chns_present;
    UCHAR exclude_mask[2]; /* MAX_NUMBER_CHANNELS/8 */
  } mpegDrc;

  /* ETSI: addtl ancillary data */
  struct {
    /* Heavy Compression */
    UCHAR compression_on;    /* flag, if compression value should be written */
    UCHAR compression_value; /* compression value */
    AACENC_METADATA_DRC_PROFILE comp_profile;
    INT comp_TargetRefLevel; /* used for Limiter */
    INT timecode_coarse_status;
    INT timecode_fine_status;

    UCHAR extAncDataStatus;

    struct {
      UCHAR ext_downmix_lvl_status;
      UCHAR ext_downmix_gain_status;
      UCHAR ext_lfe_downmix_status;
      UCHAR
      ext_dmix_a_idx; /* extended downmix level (0..7, according to table)
                       */
      UCHAR
      ext_dmix_b_idx; /* extended downmix level (0..7, according to table)
                       */
      UCHAR dmx_gain_5_sgn;
      UCHAR dmx_gain_5_idx;
      UCHAR dmx_gain_2_sgn;
      UCHAR dmx_gain_2_idx;
      UCHAR ext_dmix_lfe_idx; /* extended downmix level for lfe (0..15,
                                 according to table) */

    } extAncData;

  } etsiAncData;

  SCHAR centerMixLevel; /* center downmix level (0...7, according to table) */
  SCHAR
  surroundMixLevel; /* surround downmix level (0...7, according to table) */
  UCHAR WritePCEMixDwnIdx; /* flag */
  UCHAR DmxLvl_On;         /* flag */

  UCHAR dolbySurroundMode;
  UCHAR drcPresentationMode;

  UCHAR
  metadataMode; /* indicate meta data mode in current frame (delay line) */

} AAC_METADATA;

typedef struct FDK_METADATA_ENCODER {
  INT metadataMode;
  HDRC_COMP hDrcComp;
  AACENC_MetaData submittedMetaData;

  INT nAudioDataDelay; /* Additional delay to round up to next frame border (in
                          samples) */
  INT nMetaDataDelay;  /* Meta data delay (in frames) */
  INT nChannels;
  CHANNEL_MODE channelMode;

  INT_PCM* pAudioDelayBuffer;

  AAC_METADATA metaDataBuffer[MAX_DELAY_FRAMES];
  INT metaDataDelayIdx;

  UCHAR drcInfoPayload[12];
  UCHAR drcDsePayload[8];

  INT matrix_mixdown_idx;

  AACENC_EXT_PAYLOAD exPayload[2];
  INT nExtensions;

  UINT maxChannels; /* Maximum number of audio channels to be supported. */

  INT finalizeMetaData;   /* Delay switch off by one frame and write default
                             configuration to   finalize the metadata setup. */
  INT initializeMetaData; /* Fill up delay line with first meta data info. This
                             is required to have meta data already in first
                             frame. */
} FDK_METADATA_ENCODER;

/*---------------- constants -----------------------*/
static const AACENC_MetaData defaultMetaDataSetup = {
    AACENC_METADATA_DRC_NONE,        /* drc_profile */
    AACENC_METADATA_DRC_NOT_PRESENT, /* comp_profile */
    -(31 << 16),                     /* drc_TargetRefLevel */
    -(23 << 16),                     /* comp_TargetRefLevel */
    0,                               /* prog_ref_level_present */
    -(23 << 16),                     /* prog_ref_level */
    0,                               /* PCE_mixdown_idx_present */
    0,                               /* ETSI_DmxLvl_present */
    0,                               /* centerMixLevel */
    0,                               /* surroundMixLevel */
    0,                               /* dolbySurroundMode */
    0,                               /* drcPresentationMode */
    {0, 0, 0, 0, 0, 0, 0, 0, 0}      /* ExtMetaData */
};

static const FIXP_DBL dmxTable[8] = {
    ((FIXP_DBL)MAXVAL_DBL), FL2FXCONST_DBL(0.841f), FL2FXCONST_DBL(0.707f),
    FL2FXCONST_DBL(0.596f), FL2FXCONST_DBL(0.500f), FL2FXCONST_DBL(0.422f),
    FL2FXCONST_DBL(0.355f), FL2FXCONST_DBL(0.000f)};

#define FL2DMXLFE(a) FL2FXCONST_DBL((a) / (1 << LFE_LEV_SCALE))
static const FIXP_DBL dmxLfeTable[16] = {
    FL2DMXLFE(3.162f), FL2DMXLFE(2.000f), FL2DMXLFE(1.679f), FL2DMXLFE(1.413f),
    FL2DMXLFE(1.189f), FL2DMXLFE(1.000f), FL2DMXLFE(0.841f), FL2DMXLFE(0.707f),
    FL2DMXLFE(0.596f), FL2DMXLFE(0.500f), FL2DMXLFE(0.316f), FL2DMXLFE(0.178f),
    FL2DMXLFE(0.100f), FL2DMXLFE(0.032f), FL2DMXLFE(0.010f), FL2DMXLFE(0.000f)};

static const UCHAR surmix2matrix_mixdown_idx[8] = {0, 0, 0, 1, 1, 2, 2, 3};

/*--------------- function declarations --------------------*/
static FDK_METADATA_ERROR WriteMetadataPayload(
    const HANDLE_FDK_METADATA_ENCODER hMetaData,
    const AAC_METADATA* const pMetadata);

static INT WriteDynamicRangeInfoPayload(const AAC_METADATA* const pMetadata,
                                        UCHAR* const pExtensionPayload);

static INT WriteEtsiAncillaryDataPayload(const AAC_METADATA* const pMetadata,
                                         UCHAR* const pExtensionPayload);

static FDK_METADATA_ERROR CompensateAudioDelay(
    HANDLE_FDK_METADATA_ENCODER hMetaDataEnc, INT_PCM* const pAudioSamples,
    const UINT audioSamplesBufSize, const INT nAudioSamples);

static FDK_METADATA_ERROR LoadSubmittedMetadata(
    const AACENC_MetaData* const hMetadata, const INT nChannels,
    const INT metadataMode, AAC_METADATA* const pAacMetaData);

static FDK_METADATA_ERROR ProcessCompressor(AAC_METADATA* pMetadata,
                                            HDRC_COMP hDrcComp,
                                            const INT_PCM* const pSamples,
                                            const UINT samplesBufSize,
                                            const INT nSamples);

/*------------- function definitions ----------------*/

static DRC_PROFILE convertProfile(AACENC_METADATA_DRC_PROFILE aacProfile) {
  DRC_PROFILE drcProfile = DRC_NONE;

  switch (aacProfile) {
    case AACENC_METADATA_DRC_NONE:
      drcProfile = DRC_NONE;
      break;
    case AACENC_METADATA_DRC_FILMSTANDARD:
      drcProfile = DRC_FILMSTANDARD;
      break;
    case AACENC_METADATA_DRC_FILMLIGHT:
      drcProfile = DRC_FILMLIGHT;
      break;
    case AACENC_METADATA_DRC_MUSICSTANDARD:
      drcProfile = DRC_MUSICSTANDARD;
      break;
    case AACENC_METADATA_DRC_MUSICLIGHT:
      drcProfile = DRC_MUSICLIGHT;
      break;
    case AACENC_METADATA_DRC_SPEECH:
      drcProfile = DRC_SPEECH;
      break;
    case AACENC_METADATA_DRC_NOT_PRESENT:
      drcProfile = DRC_NOT_PRESENT;
      break;
    default:
      drcProfile = DRC_NONE;
      break;
  }
  return drcProfile;
}

/* convert dialog normalization to program reference level */
/* NOTE: this only is correct, if the decoder target level is set to -31dB for
 * line mode / -20dB for RF mode */
static UCHAR dialnorm2progreflvl(const INT d) {
  return ((UCHAR)fMax(0, fMin((-d + (1 << 13)) >> 14, 127)));
}

/* convert program reference level to dialog normalization */
static INT progreflvl2dialnorm(const UCHAR p) {
  return -((INT)(p << (16 - 2)));
}

/* encode downmix levels to Downmixing_levels_MPEG4 */
static SCHAR encodeDmxLvls(const SCHAR cmixlev, const SCHAR surmixlev) {
  SCHAR dmxLvls = 0;
  dmxLvls |= 0x80 | (cmixlev << 4); /* center_mix_level_on */
  dmxLvls |= 0x08 | surmixlev;      /* surround_mix_level_on */

  return dmxLvls;
}

/* encode AAC DRC gain (ISO/IEC 14496-3:2005  4.5.2.7) */
static void encodeDynrng(INT gain, UCHAR* const dyn_rng_ctl,
                         UCHAR* const dyn_rng_sgn) {
  if (gain < 0) {
    *dyn_rng_sgn = 1;
    gain = -gain;
  } else {
    *dyn_rng_sgn = 0;
  }
  gain = fMin(gain, (127 << 14));

  *dyn_rng_ctl = (UCHAR)((gain + (1 << 13)) >> 14);
}

/* decode AAC DRC gain (ISO/IEC 14496-3:2005  4.5.2.7) */
static INT decodeDynrng(const UCHAR dyn_rng_ctl, const UCHAR dyn_rng_sgn) {
  INT tmp = ((INT)dyn_rng_ctl << (16 - 2));
  if (dyn_rng_sgn) tmp = -tmp;

  return tmp;
}

/* encode AAC compression value (ETSI TS 101 154 page 99) */
static UCHAR encodeCompr(INT gain) {
  UCHAR x, y;
  INT tmp;

  /* tmp = (int)((48.164f - gain) / 6.0206f * 15 + 0.5f); */
  tmp = ((3156476 - gain) * 15 + 197283) / 394566;

  if (tmp >= 240) {
    return 0xFF;
  } else if (tmp < 0) {
    return 0;
  } else {
    x = tmp / 15;
    y = tmp % 15;
  }

  return (x << 4) | y;
}

/* decode AAC compression value (ETSI TS 101 154 page 99) */
static INT decodeCompr(const UCHAR compr) {
  INT gain;
  SCHAR x = compr >> 4;     /* 4 MSB of compr */
  UCHAR y = (compr & 0x0F); /* 4 LSB of compr */

  /* gain = (INT)((48.164f - 6.0206f * x - 0.4014f * y) ); */
  gain = (INT)(
      scaleValue((FIXP_DBL)(((LONG)FL2FXCONST_DBL(6.0206f / 128.f) * (8 - x) -
                             (LONG)FL2FXCONST_DBL(0.4014f / 128.f) * y)),
                 -(DFRACT_BITS - 1 - 7 - 16)));

  return gain;
}

FDK_METADATA_ERROR FDK_MetadataEnc_Open(HANDLE_FDK_METADATA_ENCODER* phMetaData,
                                        const UINT maxChannels) {
  FDK_METADATA_ERROR err = METADATA_OK;
  HANDLE_FDK_METADATA_ENCODER hMetaData = NULL;

  if (phMetaData == NULL) {
    err = METADATA_INVALID_HANDLE;
    goto bail;
  }

  /* allocate memory */
  if (NULL == (hMetaData = (HANDLE_FDK_METADATA_ENCODER)FDKcalloc(
                   1, sizeof(FDK_METADATA_ENCODER)))) {
    err = METADATA_MEMORY_ERROR;
    goto bail;
  }
  FDKmemclear(hMetaData, sizeof(FDK_METADATA_ENCODER));

  if (NULL == (hMetaData->pAudioDelayBuffer = (INT_PCM*)FDKcalloc(
                   maxChannels * MAX_DRC_FRAMELEN, sizeof(INT_PCM)))) {
    err = METADATA_MEMORY_ERROR;
    goto bail;
  }
  FDKmemclear(hMetaData->pAudioDelayBuffer,
              maxChannels * MAX_DRC_FRAMELEN * sizeof(INT_PCM));
  hMetaData->maxChannels = maxChannels;

  /* Allocate DRC Compressor. */
  if (FDK_DRC_Generator_Open(&hMetaData->hDrcComp) != 0) {
    err = METADATA_MEMORY_ERROR;
    goto bail;
  }
  hMetaData->channelMode = MODE_UNKNOWN;

  /* Return metadata instance */
  *phMetaData = hMetaData;

  return err;

bail:
  FDK_MetadataEnc_Close(&hMetaData);
  return err;
}

FDK_METADATA_ERROR FDK_MetadataEnc_Close(
    HANDLE_FDK_METADATA_ENCODER* phMetaData) {
  FDK_METADATA_ERROR err = METADATA_OK;

  if (phMetaData == NULL) {
    err = METADATA_INVALID_HANDLE;
    goto bail;
  }

  if (*phMetaData != NULL) {
    FDK_DRC_Generator_Close(&(*phMetaData)->hDrcComp);
    FDKfree((*phMetaData)->pAudioDelayBuffer);
    FDKfree(*phMetaData);
    *phMetaData = NULL;
  }
bail:
  return err;
}

FDK_METADATA_ERROR FDK_MetadataEnc_Init(
    HANDLE_FDK_METADATA_ENCODER hMetaData, const INT resetStates,
    const INT metadataMode, const INT audioDelay, const UINT frameLength,
    const UINT sampleRate, const UINT nChannels, const CHANNEL_MODE channelMode,
    const CHANNEL_ORDER channelOrder) {
  FDK_METADATA_ERROR err = METADATA_OK;
  int i, nFrames, delay;

  if (hMetaData == NULL) {
    err = METADATA_INVALID_HANDLE;
    goto bail;
  }

  /* Determine values for delay compensation. */
  for (nFrames = 0, delay = audioDelay - (INT)frameLength; delay > 0;
       delay -= (INT)frameLength, nFrames++)
    ;

  if ((nChannels > (8)) || (nChannels > hMetaData->maxChannels) ||
      ((-delay) > MAX_DRC_FRAMELEN) || nFrames >= MAX_DELAY_FRAMES) {
    err = METADATA_INIT_ERROR;
    goto bail;
  }

  /* Initialize with default setup. */
  FDKmemcpy(&hMetaData->submittedMetaData, &defaultMetaDataSetup,
            sizeof(AACENC_MetaData));

  hMetaData->finalizeMetaData =
      0; /* finalize meta data only while on/off switching, else disabled */
  hMetaData->initializeMetaData =
      0; /* fill up meta data delay line only at a reset otherwise disabled */

  /* Reset delay lines. */
  if (resetStates || (hMetaData->nAudioDataDelay != -delay) ||
      (hMetaData->channelMode != channelMode)) {
    if (resetStates || (hMetaData->channelMode == MODE_UNKNOWN)) {
      /* clear delay buffer */
      FDKmemclear(hMetaData->pAudioDelayBuffer,
                  hMetaData->maxChannels * MAX_DRC_FRAMELEN * sizeof(INT_PCM));
    } else {
      /* if possible, keep static audio channels for seamless channel
       * reconfiguration */
      FDK_channelMapDescr mapDescrPrev, mapDescr;
      int c, src[2] = {-1, -1}, dst[2] = {-1, -1};

      FDK_chMapDescr_init(&mapDescrPrev, NULL, 0,
                          (channelOrder == CH_ORDER_MPEG) ? 1 : 0);
      FDK_chMapDescr_init(&mapDescr, NULL, 0,
                          (channelOrder == CH_ORDER_MPEG) ? 1 : 0);

      switch (channelMode) {
        case MODE_1:
          if ((INT)nChannels != 2) {
            /* preserve center channel */
            src[0] = FDK_chMapDescr_getMapValue(&mapDescrPrev, 0,
                                                hMetaData->channelMode);
            dst[0] = FDK_chMapDescr_getMapValue(&mapDescr, 0, channelMode);
          }
          break;
        case MODE_2:
        case MODE_1_2:
        case MODE_1_2_1:
        case MODE_1_2_2:
        case MODE_1_2_2_1:
          if (hMetaData->nChannels >= 2) {
            /* preserve left/right channel */
            src[0] = FDK_chMapDescr_getMapValue(
                &mapDescrPrev, ((hMetaData->channelMode == 2) ? 0 : 1),
                hMetaData->channelMode);
            src[1] = FDK_chMapDescr_getMapValue(
                &mapDescrPrev, ((hMetaData->channelMode == 2) ? 1 : 2),
                hMetaData->channelMode);
            dst[0] = FDK_chMapDescr_getMapValue(
                &mapDescr, ((channelMode == 2) ? 0 : 1), channelMode);
            dst[1] = FDK_chMapDescr_getMapValue(
                &mapDescr, ((channelMode == 2) ? 1 : 2), channelMode);
          }
          break;
        default:;
      }
      C_ALLOC_SCRATCH_START(scratch_audioDelayBuffer, INT_PCM, (8));
      FDKmemclear(scratch_audioDelayBuffer, (8) * sizeof(INT_PCM));

      i = (hMetaData->nChannels > (INT)nChannels)
              ? 0
              : hMetaData->nAudioDataDelay - 1;
      do {
        for (c = 0; c < 2; c++) {
          if (src[c] != -1 && dst[c] != -1) {
            scratch_audioDelayBuffer[dst[c]] =
                hMetaData->pAudioDelayBuffer[i * hMetaData->nChannels + src[c]];
          }
        }
        FDKmemcpy(&hMetaData->pAudioDelayBuffer[i * nChannels],
                  scratch_audioDelayBuffer, nChannels * sizeof(INT_PCM));
        i += (hMetaData->nChannels > (INT)nChannels) ? 1 : -1;
      } while ((i < hMetaData->nAudioDataDelay) && (i >= 0));

      C_ALLOC_SCRATCH_END(scratch_audioDelayBuffer, INT_PCM, (8));
    }
    FDKmemclear(hMetaData->metaDataBuffer, sizeof(hMetaData->metaDataBuffer));
    hMetaData->metaDataDelayIdx = 0;
    hMetaData->initializeMetaData =
        1; /* fill up delay line with first meta data info */
  } else {
    /* Enable meta data. */
    if ((hMetaData->metadataMode == 0) && (metadataMode != 0)) {
      /* disable meta data in all delay lines */
      for (i = 0;
           i < (int)(sizeof(hMetaData->metaDataBuffer) / sizeof(AAC_METADATA));
           i++) {
        LoadSubmittedMetadata(&hMetaData->submittedMetaData, nChannels, 0,
                              &hMetaData->metaDataBuffer[i]);
      }
    }

    /* Disable meta data.*/
    if ((hMetaData->metadataMode != 0) && (metadataMode == 0)) {
      hMetaData->finalizeMetaData = hMetaData->metadataMode;
    }
  }

  /* Initialize delay. */
  hMetaData->nAudioDataDelay = -delay;
  hMetaData->nMetaDataDelay = nFrames;
  hMetaData->nChannels = nChannels;
  hMetaData->channelMode = channelMode;
  hMetaData->metadataMode = metadataMode;

  /* Initialize compressor. */
  if ((metadataMode == 1) || (metadataMode == 2)) {
    if (FDK_DRC_Generator_Initialize(hMetaData->hDrcComp, DRC_NONE, DRC_NONE,
                                     frameLength, sampleRate, channelMode,
                                     channelOrder, 1) != 0) {
      err = METADATA_INIT_ERROR;
    }
  }
bail:
  return err;
}

static FDK_METADATA_ERROR ProcessCompressor(AAC_METADATA* pMetadata,
                                            HDRC_COMP hDrcComp,
                                            const INT_PCM* const pSamples,
                                            const UINT samplesBufSize,
                                            const INT nSamples) {
  FDK_METADATA_ERROR err = METADATA_OK;

  INT dynrng, compr;
  INT dmxGain5, dmxGain2;
  DRC_PROFILE profileDrc;
  DRC_PROFILE profileComp;

  if ((pMetadata == NULL) || (hDrcComp == NULL)) {
    err = METADATA_INVALID_HANDLE;
    return err;
  }

  profileDrc = convertProfile(pMetadata->mpegDrc.drc_profile);
  profileComp = convertProfile(pMetadata->etsiAncData.comp_profile);

  /* first, check if profile is same as last frame
   * otherwise, update setup */
  if ((profileDrc != FDK_DRC_Generator_getDrcProfile(hDrcComp)) ||
      (profileComp != FDK_DRC_Generator_getCompProfile(hDrcComp))) {
    FDK_DRC_Generator_setDrcProfile(hDrcComp, profileDrc, profileComp);
  }

  /* Sanity check */
  if (profileComp == DRC_NONE) {
    pMetadata->etsiAncData.compression_value = 0x80; /* to ensure no external
                                                        values will be written
                                                        if not configured */
  }

  /* in case of embedding external values, copy this now (limiter may overwrite
   * them) */
  dynrng = decodeDynrng(pMetadata->mpegDrc.dyn_rng_ctl[0],
                        pMetadata->mpegDrc.dyn_rng_sgn[0]);
  compr = decodeCompr(pMetadata->etsiAncData.compression_value);

  dmxGain5 = decodeDynrng(pMetadata->etsiAncData.extAncData.dmx_gain_5_idx,
                          pMetadata->etsiAncData.extAncData.dmx_gain_5_sgn);
  dmxGain2 = decodeDynrng(pMetadata->etsiAncData.extAncData.dmx_gain_2_idx,
                          pMetadata->etsiAncData.extAncData.dmx_gain_2_sgn);

  /* Call compressor */
  if (FDK_DRC_Generator_Calc(
          hDrcComp, pSamples, samplesBufSize,
          progreflvl2dialnorm(pMetadata->mpegDrc.prog_ref_level),
          pMetadata->mpegDrc.drc_TargetRefLevel,
          pMetadata->etsiAncData.comp_TargetRefLevel,
          dmxTable[pMetadata->centerMixLevel],
          dmxTable[pMetadata->surroundMixLevel],
          dmxTable[pMetadata->etsiAncData.extAncData.ext_dmix_a_idx],
          dmxTable[pMetadata->etsiAncData.extAncData.ext_dmix_b_idx],
          pMetadata->etsiAncData.extAncData.ext_lfe_downmix_status
              ? dmxLfeTable[pMetadata->etsiAncData.extAncData.ext_dmix_lfe_idx]
              : (FIXP_DBL)0,
          dmxGain5, dmxGain2, &dynrng, &compr) != 0) {
    err = METADATA_ENCODE_ERROR;
    goto bail;
  }

  /* Write DRC values */
  pMetadata->mpegDrc.drc_band_incr = 0;
  encodeDynrng(dynrng, pMetadata->mpegDrc.dyn_rng_ctl,
               pMetadata->mpegDrc.dyn_rng_sgn);
  pMetadata->etsiAncData.compression_value = encodeCompr(compr);

bail:
  return err;
}

FDK_METADATA_ERROR FDK_MetadataEnc_Process(
    HANDLE_FDK_METADATA_ENCODER hMetaDataEnc, INT_PCM* const pAudioSamples,
    const UINT audioSamplesBufSize, const INT nAudioSamples,
    const AACENC_MetaData* const pMetadata,
    AACENC_EXT_PAYLOAD** ppMetaDataExtPayload, UINT* nMetaDataExtensions,
    INT* matrix_mixdown_idx) {
  FDK_METADATA_ERROR err = METADATA_OK;
  int metaDataDelayWriteIdx, metaDataDelayReadIdx, metadataMode;

  /* Where to write new meta data info */
  metaDataDelayWriteIdx = hMetaDataEnc->metaDataDelayIdx;

  /* How to write the data */
  metadataMode = hMetaDataEnc->metadataMode;

  /* Compensate meta data delay. */
  hMetaDataEnc->metaDataDelayIdx++;
  if (hMetaDataEnc->metaDataDelayIdx > hMetaDataEnc->nMetaDataDelay)
    hMetaDataEnc->metaDataDelayIdx = 0;

  /* Where to read pending meta data info from. */
  metaDataDelayReadIdx = hMetaDataEnc->metaDataDelayIdx;

  /* Submit new data if available. */
  if (pMetadata != NULL) {
    FDKmemcpy(&hMetaDataEnc->submittedMetaData, pMetadata,
              sizeof(AACENC_MetaData));
  }

  /* Write one additional frame with default configuration of meta data. Ensure
   * defined behaviour on decoder side. */
  if ((hMetaDataEnc->finalizeMetaData != 0) &&
      (hMetaDataEnc->metadataMode == 0)) {
    FDKmemcpy(&hMetaDataEnc->submittedMetaData, &defaultMetaDataSetup,
              sizeof(AACENC_MetaData));
    metadataMode = hMetaDataEnc->finalizeMetaData;
    hMetaDataEnc->finalizeMetaData = 0;
  }

  /* Get last submitted data. */
  if ((err = LoadSubmittedMetadata(
           &hMetaDataEnc->submittedMetaData, hMetaDataEnc->nChannels,
           metadataMode,
           &hMetaDataEnc->metaDataBuffer[metaDataDelayWriteIdx])) !=
      METADATA_OK) {
    goto bail;
  }

  /* Calculate compressor if necessary and updata meta data info */
  if ((hMetaDataEnc->metaDataBuffer[metaDataDelayWriteIdx].metadataMode == 1) ||
      (hMetaDataEnc->metaDataBuffer[metaDataDelayWriteIdx].metadataMode == 2)) {
    if ((err = ProcessCompressor(
             &hMetaDataEnc->metaDataBuffer[metaDataDelayWriteIdx],
             hMetaDataEnc->hDrcComp, pAudioSamples, audioSamplesBufSize,
             nAudioSamples)) != METADATA_OK) {
      /* Get last submitted data again. */
      LoadSubmittedMetadata(
          &hMetaDataEnc->submittedMetaData, hMetaDataEnc->nChannels,
          metadataMode, &hMetaDataEnc->metaDataBuffer[metaDataDelayWriteIdx]);
    }
  }

  /* Fill up delay line with initial meta data info.*/
  if ((hMetaDataEnc->initializeMetaData != 0) &&
      (hMetaDataEnc->metadataMode != 0)) {
    int i;
    for (i = 0;
         i < (int)(sizeof(hMetaDataEnc->metaDataBuffer) / sizeof(AAC_METADATA));
         i++) {
      if (i != metaDataDelayWriteIdx) {
        FDKmemcpy(&hMetaDataEnc->metaDataBuffer[i],
                  &hMetaDataEnc->metaDataBuffer[metaDataDelayWriteIdx],
                  sizeof(hMetaDataEnc->metaDataBuffer[metaDataDelayWriteIdx]));
      }
    }
    hMetaDataEnc->initializeMetaData = 0;
  }

  /* Convert Meta Data side info to bitstream data. */
  FDK_ASSERT(metaDataDelayReadIdx < MAX_DELAY_FRAMES);
  if ((err = WriteMetadataPayload(
           hMetaDataEnc,
           &hMetaDataEnc->metaDataBuffer[metaDataDelayReadIdx])) !=
      METADATA_OK) {
    goto bail;
  }

  /* Assign meta data to output */
  *ppMetaDataExtPayload = hMetaDataEnc->exPayload;
  *nMetaDataExtensions = hMetaDataEnc->nExtensions;
  *matrix_mixdown_idx = hMetaDataEnc->matrix_mixdown_idx;

bail:
  /* Compensate audio delay, reset err status. */
  err = CompensateAudioDelay(hMetaDataEnc, pAudioSamples, audioSamplesBufSize,
                             nAudioSamples / hMetaDataEnc->nChannels);

  return err;
}

static FDK_METADATA_ERROR CompensateAudioDelay(
    HANDLE_FDK_METADATA_ENCODER hMetaDataEnc, INT_PCM* const pAudioSamples,
    const UINT audioSamplesBufSize, const INT nAudioSamples) {
  FDK_METADATA_ERROR err = METADATA_OK;

  if (hMetaDataEnc->nAudioDataDelay) {
    C_ALLOC_SCRATCH_START(scratch_audioDelayBuffer, INT_PCM, 1024);

    for (int c = 0; c < hMetaDataEnc->nChannels; c++) {
      int M = 1024;
      INT_PCM* pAudioSamples2 = pAudioSamples + c * audioSamplesBufSize;
      int delayIdx = hMetaDataEnc->nAudioDataDelay;

      do {
        M = fMin(M, delayIdx);
        delayIdx -= M;

        FDKmemcpy(&scratch_audioDelayBuffer[0],
                  &pAudioSamples2[(nAudioSamples - M)], sizeof(INT_PCM) * M);
        FDKmemmove(&pAudioSamples2[M], &pAudioSamples2[0],
                   sizeof(INT_PCM) * (nAudioSamples - M));
        FDKmemcpy(
            &pAudioSamples2[0],
            &hMetaDataEnc->pAudioDelayBuffer[delayIdx +
                                             c * hMetaDataEnc->nAudioDataDelay],
            sizeof(INT_PCM) * M);
        FDKmemcpy(
            &hMetaDataEnc->pAudioDelayBuffer[delayIdx +
                                             c * hMetaDataEnc->nAudioDataDelay],
            &scratch_audioDelayBuffer[0], sizeof(INT_PCM) * M);

      } while (delayIdx > 0);
    }

    C_ALLOC_SCRATCH_END(scratch_audioDelayBuffer, INT_PCM, 1024);
  }

  return err;
}

/*-----------------------------------------------------------------------------

  functionname: WriteMetadataPayload
  description:  fills anc data and extension payload
  returns:      Error status

 ------------------------------------------------------------------------------*/
static FDK_METADATA_ERROR WriteMetadataPayload(
    const HANDLE_FDK_METADATA_ENCODER hMetaData,
    const AAC_METADATA* const pMetadata) {
  FDK_METADATA_ERROR err = METADATA_OK;

  if ((hMetaData == NULL) || (pMetadata == NULL)) {
    err = METADATA_INVALID_HANDLE;
    goto bail;
  }

  hMetaData->nExtensions = 0;
  hMetaData->matrix_mixdown_idx = -1;

  if (pMetadata->metadataMode != 0) {
    /* AAC-DRC */
    if ((pMetadata->metadataMode == 1) || (pMetadata->metadataMode == 2)) {
      hMetaData->exPayload[hMetaData->nExtensions].pData =
          hMetaData->drcInfoPayload;
      hMetaData->exPayload[hMetaData->nExtensions].dataType = EXT_DYNAMIC_RANGE;
      hMetaData->exPayload[hMetaData->nExtensions].associatedChElement = -1;

      hMetaData->exPayload[hMetaData->nExtensions].dataSize =
          WriteDynamicRangeInfoPayload(
              pMetadata, hMetaData->exPayload[hMetaData->nExtensions].pData);

      hMetaData->nExtensions++;
    } /* pMetadata->metadataMode==1 || pMetadata->metadataMode==2 */

    /* Matrix Mixdown Coefficient in PCE */
    if (pMetadata->WritePCEMixDwnIdx) {
      hMetaData->matrix_mixdown_idx =
          surmix2matrix_mixdown_idx[pMetadata->surroundMixLevel];
    }

    /* ETSI TS 101 154 (DVB) - MPEG4 ancillary_data() */
    if ((pMetadata->metadataMode == 2) ||
        (pMetadata->metadataMode == 3)) /* MP4_METADATA_MPEG_ETSI */
    {
      hMetaData->exPayload[hMetaData->nExtensions].pData =
          hMetaData->drcDsePayload;
      hMetaData->exPayload[hMetaData->nExtensions].dataType = EXT_DATA_ELEMENT;
      hMetaData->exPayload[hMetaData->nExtensions].associatedChElement = -1;

      hMetaData->exPayload[hMetaData->nExtensions].dataSize =
          WriteEtsiAncillaryDataPayload(
              pMetadata, hMetaData->exPayload[hMetaData->nExtensions].pData);

      hMetaData->nExtensions++;
    } /* metadataMode==2 || metadataMode==3 */

  } /* metadataMode != 0 */

bail:
  return err;
}

static INT WriteDynamicRangeInfoPayload(const AAC_METADATA* const pMetadata,
                                        UCHAR* const pExtensionPayload) {
  const INT pce_tag_present = 0; /* yet fixed setting! */
  const INT prog_ref_lev_res_bits = 0;
  INT i, drc_num_bands = 1;

  FDK_BITSTREAM bsWriter;
  FDKinitBitStream(&bsWriter, pExtensionPayload, 16, 0, BS_WRITER);

  /* dynamic_range_info() */
  FDKwriteBits(&bsWriter, pce_tag_present, 1); /* pce_tag_present */
  if (pce_tag_present) {
    FDKwriteBits(&bsWriter, 0x0, 4); /* pce_instance_tag */
    FDKwriteBits(&bsWriter, 0x0, 4); /* drc_tag_reserved_bits */
  }

  /* Exclude channels */
  FDKwriteBits(&bsWriter, (pMetadata->mpegDrc.excluded_chns_present) ? 1 : 0,
               1); /* excluded_chns_present*/

  /* Multiband DRC */
  FDKwriteBits(&bsWriter, (pMetadata->mpegDrc.drc_bands_present) ? 1 : 0,
               1); /* drc_bands_present */
  if (pMetadata->mpegDrc.drc_bands_present) {
    FDKwriteBits(&bsWriter, pMetadata->mpegDrc.drc_band_incr,
                 4); /* drc_band_incr */
    FDKwriteBits(&bsWriter, pMetadata->mpegDrc.drc_interpolation_scheme,
                 4); /* drc_interpolation_scheme */
    drc_num_bands += pMetadata->mpegDrc.drc_band_incr;
    for (i = 0; i < drc_num_bands; i++) {
      FDKwriteBits(&bsWriter, pMetadata->mpegDrc.drc_band_top[i],
                   8); /* drc_band_top */
    }
  }

  /* Program Reference Level */
  FDKwriteBits(&bsWriter, pMetadata->mpegDrc.prog_ref_level_present,
               1); /* prog_ref_level_present */
  if (pMetadata->mpegDrc.prog_ref_level_present) {
    FDKwriteBits(&bsWriter, pMetadata->mpegDrc.prog_ref_level,
                 7); /* prog_ref_level */
    FDKwriteBits(&bsWriter, prog_ref_lev_res_bits,
                 1); /* prog_ref_level_reserved_bits */
  }

  /* DRC Values */
  for (i = 0; i < drc_num_bands; i++) {
    FDKwriteBits(&bsWriter, (pMetadata->mpegDrc.dyn_rng_sgn[i]) ? 1 : 0,
                 1); /* dyn_rng_sgn[ */
    FDKwriteBits(&bsWriter, pMetadata->mpegDrc.dyn_rng_ctl[i],
                 7); /* dyn_rng_ctl */
  }

  /* return number of valid bits in extension payload. */
  return FDKgetValidBits(&bsWriter);
}

static INT WriteEtsiAncillaryDataPayload(const AAC_METADATA* const pMetadata,
                                         UCHAR* const pExtensionPayload) {
  FDK_BITSTREAM bsWriter;
  FDKinitBitStream(&bsWriter, pExtensionPayload, 16, 0, BS_WRITER);

  /* ancillary_data_sync */
  FDKwriteBits(&bsWriter, 0xBC, 8);

  /* bs_info */
  FDKwriteBits(&bsWriter, 0x3, 2); /* mpeg_audio_type */
  FDKwriteBits(&bsWriter, pMetadata->dolbySurroundMode,
               2); /* dolby_surround_mode */
  FDKwriteBits(&bsWriter, pMetadata->drcPresentationMode,
               2);                 /* DRC presentation mode */
  FDKwriteBits(&bsWriter, 0x0, 1); /* stereo_downmix_mode */
  FDKwriteBits(&bsWriter, 0x0, 1); /* reserved */

  /* ancillary_data_status */
  FDKwriteBits(&bsWriter, 0, 3); /* 3 bit Reserved, set to "0" */
  FDKwriteBits(&bsWriter, (pMetadata->DmxLvl_On) ? 1 : 0,
               1); /* downmixing_levels_MPEG4_status */
  FDKwriteBits(&bsWriter, pMetadata->etsiAncData.extAncDataStatus,
               1); /* ext_anc_data_status */
  FDKwriteBits(&bsWriter, (pMetadata->etsiAncData.compression_on) ? 1 : 0,
               1); /* audio_coding_mode_and_compression status */
  FDKwriteBits(&bsWriter,
               (pMetadata->etsiAncData.timecode_coarse_status) ? 1 : 0,
               1); /* coarse_grain_timecode_status */
  FDKwriteBits(&bsWriter, (pMetadata->etsiAncData.timecode_fine_status) ? 1 : 0,
               1); /* fine_grain_timecode_status */

  /* downmixing_levels_MPEG4_status */
  if (pMetadata->DmxLvl_On) {
    FDKwriteBits(
        &bsWriter,
        encodeDmxLvls(pMetadata->centerMixLevel, pMetadata->surroundMixLevel),
        8);
  }

  /* audio_coding_mode_and_compression_status */
  if (pMetadata->etsiAncData.compression_on) {
    FDKwriteBits(&bsWriter, 0x01, 8); /* audio coding mode */
    FDKwriteBits(&bsWriter, pMetadata->etsiAncData.compression_value,
                 8); /* compression value */
  }

  /* grain-timecode coarse/fine */
  if (pMetadata->etsiAncData.timecode_coarse_status) {
    FDKwriteBits(&bsWriter, 0x0, 16); /* not yet supported */
  }

  if (pMetadata->etsiAncData.timecode_fine_status) {
    FDKwriteBits(&bsWriter, 0x0, 16); /* not yet supported */
  }

  /* extended ancillary data structure */
  if (pMetadata->etsiAncData.extAncDataStatus) {
    /* ext_ancillary_data_status */
    FDKwriteBits(&bsWriter, 0, 1); /* Reserved, set to "0" */
    FDKwriteBits(&bsWriter,
                 pMetadata->etsiAncData.extAncData.ext_downmix_lvl_status,
                 1); /* ext_downmixing_levels_status */
    FDKwriteBits(&bsWriter,
                 pMetadata->etsiAncData.extAncData.ext_downmix_gain_status,
                 1); /* ext_downmixing_global_gains_status */
    FDKwriteBits(&bsWriter,
                 pMetadata->etsiAncData.extAncData.ext_lfe_downmix_status,
                 1);               /* ext_downmixing_lfe_level_status" */
    FDKwriteBits(&bsWriter, 0, 4); /* Reserved, set to "0" */

    /* ext_downmixing_levels */
    if (pMetadata->etsiAncData.extAncData.ext_downmix_lvl_status) {
      FDKwriteBits(&bsWriter, pMetadata->etsiAncData.extAncData.ext_dmix_a_idx,
                   3); /* dmix_a_idx */
      FDKwriteBits(&bsWriter, pMetadata->etsiAncData.extAncData.ext_dmix_b_idx,
                   3);               /* dmix_b_idx */
      FDKwriteBits(&bsWriter, 0, 2); /* Reserved, set to "0" */
    }

    /* ext_downmixing_gains */
    if (pMetadata->etsiAncData.extAncData.ext_downmix_gain_status) {
      FDKwriteBits(&bsWriter, pMetadata->etsiAncData.extAncData.dmx_gain_5_sgn,
                   1); /* dmx_gain_5_sign */
      FDKwriteBits(&bsWriter, pMetadata->etsiAncData.extAncData.dmx_gain_5_idx,
                   6);               /* dmx_gain_5_idx */
      FDKwriteBits(&bsWriter, 0, 1); /* Reserved, set to "0" */
      FDKwriteBits(&bsWriter, pMetadata->etsiAncData.extAncData.dmx_gain_2_sgn,
                   1); /* dmx_gain_2_sign */
      FDKwriteBits(&bsWriter, pMetadata->etsiAncData.extAncData.dmx_gain_2_idx,
                   6);               /* dmx_gain_2_idx */
      FDKwriteBits(&bsWriter, 0, 1); /* Reserved, set to "0" */
    }

    if (pMetadata->etsiAncData.extAncData.ext_lfe_downmix_status) {
      FDKwriteBits(&bsWriter,
                   pMetadata->etsiAncData.extAncData.ext_dmix_lfe_idx,
                   4);               /* dmix_lfe_idx */
      FDKwriteBits(&bsWriter, 0, 4); /* Reserved, set to "0" */
    }
  }

  return FDKgetValidBits(&bsWriter);
}

static FDK_METADATA_ERROR LoadSubmittedMetadata(
    const AACENC_MetaData* const hMetadata, const INT nChannels,
    const INT metadataMode, AAC_METADATA* const pAacMetaData) {
  FDK_METADATA_ERROR err = METADATA_OK;

  if (pAacMetaData == NULL) {
    err = METADATA_INVALID_HANDLE;
  } else {
    /* init struct */
    FDKmemclear(pAacMetaData, sizeof(AAC_METADATA));

    if (hMetadata != NULL) {
      /* convert data */
      pAacMetaData->mpegDrc.drc_profile = hMetadata->drc_profile;
      pAacMetaData->etsiAncData.comp_profile = hMetadata->comp_profile;
      pAacMetaData->mpegDrc.drc_TargetRefLevel = hMetadata->drc_TargetRefLevel;
      pAacMetaData->etsiAncData.comp_TargetRefLevel =
          hMetadata->comp_TargetRefLevel;
      pAacMetaData->mpegDrc.prog_ref_level_present =
          hMetadata->prog_ref_level_present;
      pAacMetaData->mpegDrc.prog_ref_level =
          dialnorm2progreflvl(hMetadata->prog_ref_level);

      pAacMetaData->centerMixLevel = hMetadata->centerMixLevel;
      pAacMetaData->surroundMixLevel = hMetadata->surroundMixLevel;
      pAacMetaData->WritePCEMixDwnIdx = hMetadata->PCE_mixdown_idx_present;
      pAacMetaData->DmxLvl_On = hMetadata->ETSI_DmxLvl_present;

      pAacMetaData->etsiAncData.compression_on =
          (hMetadata->comp_profile == AACENC_METADATA_DRC_NOT_PRESENT ? 0 : 1);

      if (pAacMetaData->mpegDrc.drc_profile ==
          AACENC_METADATA_DRC_NOT_PRESENT) {
        pAacMetaData->mpegDrc.drc_profile =
            AACENC_METADATA_DRC_NONE; /* MPEG DRC gains are
                                         always present in BS
                                         syntax */
        /* we should give a warning, but ErrorHandler does not support this */
      }

      if (nChannels == 2) {
        pAacMetaData->dolbySurroundMode =
            hMetadata->dolbySurroundMode; /* dolby_surround_mode */
      } else {
        pAacMetaData->dolbySurroundMode = 0;
      }

      pAacMetaData->drcPresentationMode = hMetadata->drcPresentationMode;
      /* override external values if DVB DRC presentation mode is given */
      if (pAacMetaData->drcPresentationMode == 1) {
        pAacMetaData->mpegDrc.drc_TargetRefLevel =
            fMax(-(31 << 16), pAacMetaData->mpegDrc.drc_TargetRefLevel);
        pAacMetaData->etsiAncData.comp_TargetRefLevel = fMax(
            -(20 << 16),
            pAacMetaData->etsiAncData.comp_TargetRefLevel); /* implies -23dB */
      }
      if (pAacMetaData->drcPresentationMode == 2) {
        pAacMetaData->mpegDrc.drc_TargetRefLevel =
            fMax(-(23 << 16), pAacMetaData->mpegDrc.drc_TargetRefLevel);
        pAacMetaData->etsiAncData.comp_TargetRefLevel =
            fMax(-(23 << 16), pAacMetaData->etsiAncData.comp_TargetRefLevel);
      }
      if (pAacMetaData->etsiAncData.comp_profile ==
          AACENC_METADATA_DRC_NOT_PRESENT) {
        /* DVB defines to revert to Light DRC if heavy is not present */
        if (pAacMetaData->drcPresentationMode != 0) {
          /* we exclude the "not indicated" mode as this requires the user to
           * define desired levels anyway */
          pAacMetaData->mpegDrc.drc_TargetRefLevel =
              fMax(pAacMetaData->etsiAncData.comp_TargetRefLevel,
                   pAacMetaData->mpegDrc.drc_TargetRefLevel);
        }
      }

      pAacMetaData->etsiAncData.timecode_coarse_status =
          0; /* not yet supported - attention: Update
                GetEstMetadataBytesPerFrame() if enable this! */
      pAacMetaData->etsiAncData.timecode_fine_status =
          0; /* not yet supported - attention: Update
                GetEstMetadataBytesPerFrame() if enable this! */

      /* extended ancillary data */
      pAacMetaData->etsiAncData.extAncDataStatus =
          ((hMetadata->ExtMetaData.extAncDataEnable == 1) ? 1 : 0);

      if (pAacMetaData->etsiAncData.extAncDataStatus) {
        pAacMetaData->etsiAncData.extAncData.ext_downmix_lvl_status =
            (hMetadata->ExtMetaData.extDownmixLevelEnable ? 1 : 0);
        pAacMetaData->etsiAncData.extAncData.ext_downmix_gain_status =
            (hMetadata->ExtMetaData.dmxGainEnable ? 1 : 0);
        pAacMetaData->etsiAncData.extAncData.ext_lfe_downmix_status =
            (hMetadata->ExtMetaData.lfeDmxEnable ? 1 : 0);

        pAacMetaData->etsiAncData.extAncData.ext_dmix_a_idx =
            hMetadata->ExtMetaData.extDownmixLevel_A;
        pAacMetaData->etsiAncData.extAncData.ext_dmix_b_idx =
            hMetadata->ExtMetaData.extDownmixLevel_B;

        if (pAacMetaData->etsiAncData.extAncData.ext_downmix_gain_status) {
          encodeDynrng(hMetadata->ExtMetaData.dmxGain5,
                       &(pAacMetaData->etsiAncData.extAncData.dmx_gain_5_idx),
                       &(pAacMetaData->etsiAncData.extAncData.dmx_gain_5_sgn));
          encodeDynrng(hMetadata->ExtMetaData.dmxGain2,
                       &(pAacMetaData->etsiAncData.extAncData.dmx_gain_2_idx),
                       &(pAacMetaData->etsiAncData.extAncData.dmx_gain_2_sgn));
        } else {
          encodeDynrng(1 << 16,
                       &(pAacMetaData->etsiAncData.extAncData.dmx_gain_5_idx),
                       &(pAacMetaData->etsiAncData.extAncData.dmx_gain_5_sgn));
          encodeDynrng(1 << 16,
                       &(pAacMetaData->etsiAncData.extAncData.dmx_gain_2_idx),
                       &(pAacMetaData->etsiAncData.extAncData.dmx_gain_2_sgn));
        }

        if (pAacMetaData->etsiAncData.extAncData.ext_lfe_downmix_status) {
          pAacMetaData->etsiAncData.extAncData.ext_dmix_lfe_idx =
              hMetadata->ExtMetaData.lfeDmxLevel;
        } else {
          pAacMetaData->etsiAncData.extAncData.ext_dmix_lfe_idx =
              15; /* -inf dB */
        }
      } else {
        pAacMetaData->etsiAncData.extAncData.ext_downmix_lvl_status = 0;
        pAacMetaData->etsiAncData.extAncData.ext_downmix_gain_status = 0;
        pAacMetaData->etsiAncData.extAncData.ext_lfe_downmix_status = 0;

        pAacMetaData->etsiAncData.extAncData.ext_dmix_a_idx = 7; /* -inf dB */
        pAacMetaData->etsiAncData.extAncData.ext_dmix_b_idx = 7; /* -inf dB */

        encodeDynrng(1 << 16,
                     &(pAacMetaData->etsiAncData.extAncData.dmx_gain_5_idx),
                     &(pAacMetaData->etsiAncData.extAncData.dmx_gain_5_sgn));
        encodeDynrng(1 << 16,
                     &(pAacMetaData->etsiAncData.extAncData.dmx_gain_2_idx),
                     &(pAacMetaData->etsiAncData.extAncData.dmx_gain_2_sgn));

        pAacMetaData->etsiAncData.extAncData.ext_dmix_lfe_idx =
            15; /* -inf dB */
      }

      pAacMetaData->metadataMode = metadataMode;
    } else {
      pAacMetaData->metadataMode = 0; /* there is no configuration available */
    }
  }

  return err;
}

INT FDK_MetadataEnc_GetDelay(HANDLE_FDK_METADATA_ENCODER hMetadataEnc) {
  INT delay = 0;

  if (hMetadataEnc != NULL) {
    delay = hMetadataEnc->nAudioDataDelay;
  }

  return delay;
}