Include patched FDK-AAC in the repository

The initial idea was to get the DAB+ patch into upstream, but since
that follows the android source releases, there is no place for a custom
DAB+ patch there.

So instead of having to maintain a patched fdk-aac that has to have the
same .so version as the distribution package on which it is installed,
we prefer having a separate fdk-aac-dab library to avoid collision.

At that point, there's no reason to keep fdk-aac in a separate
repository, as odr-audioenc is the only tool that needs DAB+ encoding
support. Including it here simplifies installation, and makes it
consistent with toolame-dab, also shipped in this repository.

DAB+ decoding support (needed by ODR-SourceCompanion, dablin, etisnoop,
welle.io and others) can be done using upstream FDK-AAC.

1 files changed, 1191 insertions, 0 deletions

diff --git a/fdk-aac/libAACenc/src/metadata_main.cpp b/fdk-aac/libAACenc/src/metadata_main.cpp
new file mode 100644
index 0000000..ada4502
--- /dev/null
+++ b/fdk-aac/libAACenc/src/metadata_main.cpp
@@ -0,0 +1,1191 @@
+/* -----------------------------------------------------------------------------
+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};
+
+      if (channelOrder == CH_ORDER_WG4) {
+        FDK_chMapDescr_init(&mapDescrPrev, FDK_mapInfoTabWg4,
+                            FDK_mapInfoTabLenWg4, 0);
+        FDK_chMapDescr_init(&mapDescr, FDK_mapInfoTabWg4,
+                            FDK_mapInfoTabLenWg4, 0);
+      } else {
+        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;
+}