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, 2029 insertions, 0 deletions

diff --git a/fdk-aac/libDRCdec/src/drcDec_reader.cpp b/fdk-aac/libDRCdec/src/drcDec_reader.cpp
new file mode 100644
index 0000000..6fe7a04
--- /dev/null
+++ b/fdk-aac/libDRCdec/src/drcDec_reader.cpp
@@ -0,0 +1,2029 @@
+/* -----------------------------------------------------------------------------
+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
+----------------------------------------------------------------------------- */
+
+/************************* MPEG-D DRC decoder library **************************
+
+   Author(s):
+
+   Description:
+
+*******************************************************************************/
+
+#include "fixpoint_math.h"
+#include "drcDec_reader.h"
+#include "drcDec_tools.h"
+#include "drcDec_rom.h"
+#include "drcDecoder.h"
+
+/* MPEG-D DRC AMD 1 */
+
+#define UNIDRCCONFEXT_PARAM_DRC 0x1
+#define UNIDRCCONFEXT_V1 0x2
+#define UNIDRCLOUDEXT_EQ 0x1
+
+#define UNIDRCGAINEXT_TERM 0x0
+#define UNIDRCLOUDEXT_TERM 0x0
+#define UNIDRCCONFEXT_TERM 0x0
+
+static int _getZ(const int nNodesMax) {
+  /* Z is the minimum codeword length that is needed to encode all possible
+   * timeDelta values */
+  /* Z = ceil(log2(2*nNodesMax)) */
+  int Z = 1;
+  while ((1 << Z) < (2 * nNodesMax)) {
+    Z++;
+  }
+  return Z;
+}
+
+static int _getTimeDeltaMin(const GAIN_SET* pGset, const int deltaTminDefault) {
+  if (pGset->timeDeltaMinPresent) {
+    return pGset->timeDeltaMin;
+  } else {
+    return deltaTminDefault;
+  }
+}
+
+/* compare and assign */
+static inline int _compAssign(UCHAR* dest, const UCHAR src) {
+  int diff = 0;
+  if (*dest != src) diff = 1;
+  *dest = src;
+  return diff;
+}
+
+static inline int _compAssign(ULONG* dest, const ULONG src) {
+  int diff = 0;
+  if (*dest != src) diff = 1;
+  *dest = src;
+  return diff;
+}
+
+typedef const SCHAR (*Huffman)[2];
+
+int _decodeHuffmanCW(Huffman h, /*!< pointer to huffman codebook table */
+                     HANDLE_FDK_BITSTREAM hBs) /*!< Handle to bitbuffer */
+{
+  SCHAR index = 0;
+  int value, bit;
+
+  while (index >= 0) {
+    bit = FDKreadBits(hBs, 1);
+    index = h[index][bit];
+  }
+
+  value = index + 64; /* Add offset */
+
+  return value;
+}
+
+/**********/
+/* uniDrc */
+/**********/
+
+DRC_ERROR
+drcDec_readUniDrc(HANDLE_FDK_BITSTREAM hBs, HANDLE_UNI_DRC_CONFIG hUniDrcConfig,
+                  HANDLE_LOUDNESS_INFO_SET hLoudnessInfoSet,
+                  const int frameSize, const int deltaTminDefault,
+                  HANDLE_UNI_DRC_GAIN hUniDrcGain) {
+  DRC_ERROR err = DE_OK;
+  int loudnessInfoSetPresent, uniDrcConfigPresent;
+
+  loudnessInfoSetPresent = FDKreadBits(hBs, 1);
+  if (loudnessInfoSetPresent) {
+    uniDrcConfigPresent = FDKreadBits(hBs, 1);
+    if (uniDrcConfigPresent) {
+      err = drcDec_readUniDrcConfig(hBs, hUniDrcConfig);
+      if (err) return err;
+    }
+    err = drcDec_readLoudnessInfoSet(hBs, hLoudnessInfoSet);
+    if (err) return err;
+  }
+
+  if (hUniDrcGain != NULL) {
+    err = drcDec_readUniDrcGain(hBs, hUniDrcConfig, frameSize, deltaTminDefault,
+                                hUniDrcGain);
+    if (err) return err;
+  }
+
+  return err;
+}
+
+/**************/
+/* uniDrcGain */
+/**************/
+
+static FIXP_SGL _decodeGainInitial(
+    HANDLE_FDK_BITSTREAM hBs, const GAIN_CODING_PROFILE gainCodingProfile) {
+  int sign, magn;
+  FIXP_SGL gainInitial = (FIXP_SGL)0;
+  switch (gainCodingProfile) {
+    case GCP_REGULAR:
+      sign = FDKreadBits(hBs, 1);
+      magn = FDKreadBits(hBs, 8);
+
+      gainInitial =
+          (FIXP_SGL)(magn << (FRACT_BITS - 1 - 3 - 7)); /* magn * 0.125; */
+      if (sign) gainInitial = -gainInitial;
+      break;
+    case GCP_FADING:
+      sign = FDKreadBits(hBs, 1);
+      if (sign == 0)
+        gainInitial = (FIXP_SGL)0;
+      else {
+        magn = FDKreadBits(hBs, 10);
+        gainInitial = -(FIXP_SGL)(
+            (magn + 1) << (FRACT_BITS - 1 - 3 - 7)); /* - (magn + 1) * 0.125; */
+      }
+      break;
+    case GCP_CLIPPING_DUCKING:
+      sign = FDKreadBits(hBs, 1);
+      if (sign == 0)
+        gainInitial = (FIXP_SGL)0;
+      else {
+        magn = FDKreadBits(hBs, 8);
+        gainInitial = -(FIXP_SGL)(
+            (magn + 1) << (FRACT_BITS - 1 - 3 - 7)); /* - (magn + 1) * 0.125; */
+      }
+      break;
+    case GCP_CONSTANT:
+      break;
+  }
+  return gainInitial;
+}
+
+static int _decodeNNodes(HANDLE_FDK_BITSTREAM hBs) {
+  int nNodes = 0, endMarker = 0;
+
+  /* decode number of nodes */
+  while (endMarker != 1) {
+    nNodes++;
+    if (nNodes >= 128) break;
+    endMarker = FDKreadBits(hBs, 1);
+  }
+  return nNodes;
+}
+
+static void _decodeGains(HANDLE_FDK_BITSTREAM hBs,
+                         const GAIN_CODING_PROFILE gainCodingProfile,
+                         const int nNodes, GAIN_NODE* pNodes) {
+  int k, deltaGain;
+  Huffman deltaGainCodebook;
+
+  pNodes[0].gainDb = _decodeGainInitial(hBs, gainCodingProfile);
+
+  if (gainCodingProfile == GCP_CLIPPING_DUCKING) {
+    deltaGainCodebook = (Huffman)&deltaGain_codingProfile_2_huffman;
+  } else {
+    deltaGainCodebook = (Huffman)&deltaGain_codingProfile_0_1_huffman;
+  }
+
+  for (k = 1; k < nNodes; k++) {
+    deltaGain = _decodeHuffmanCW(deltaGainCodebook, hBs);
+    if (k >= 16) continue;
+    /* gain_dB_e = 7 */
+    pNodes[k].gainDb =
+        pNodes[k - 1].gainDb +
+        (FIXP_SGL)(deltaGain << (FRACT_BITS - 1 - 7 -
+                                 3)); /* pNodes[k-1].gainDb + 0.125*deltaGain */
+  }
+}
+
+static void _decodeSlopes(HANDLE_FDK_BITSTREAM hBs,
+                          const GAIN_INTERPOLATION_TYPE gainInterpolationType,
+                          const int nNodes, GAIN_NODE* pNodes) {
+  int k = 0;
+
+  if (gainInterpolationType == GIT_SPLINE) {
+    /* decode slope steepness */
+    for (k = 0; k < nNodes; k++) {
+      _decodeHuffmanCW((Huffman)&slopeSteepness_huffman, hBs);
+    }
+  }
+}
+
+static int _decodeTimeDelta(HANDLE_FDK_BITSTREAM hBs, const int Z) {
+  int prefix, mu;
+
+  prefix = FDKreadBits(hBs, 2);
+  switch (prefix) {
+    case 0x0:
+      return 1;
+    case 0x1:
+      mu = FDKreadBits(hBs, 2);
+      return mu + 2;
+    case 0x2:
+      mu = FDKreadBits(hBs, 3);
+      return mu + 6;
+    case 0x3:
+      mu = FDKreadBits(hBs, Z);
+      return mu + 14;
+    default:
+      return 0;
+  }
+}
+
+static void _decodeTimes(HANDLE_FDK_BITSTREAM hBs, const int deltaTmin,
+                         const int frameSize, const int fullFrame,
+                         const int timeOffset, const int Z, const int nNodes,
+                         GAIN_NODE* pNodes) {
+  int timeDelta, k;
+  int timeOffs = timeOffset;
+  int frameEndFlag, nodeTimeTmp, nodeResFlag;
+
+  if (fullFrame == 0) {
+    frameEndFlag = FDKreadBits(hBs, 1);
+  } else {
+    frameEndFlag = 1;
+  }
+
+  if (frameEndFlag ==
+      1) { /* frameEndFlag == 1 signals that the last node is at the end of the
+              DRC frame */
+    nodeResFlag = 0;
+    for (k = 0; k < nNodes - 1; k++) {
+      /* decode a delta time value */
+      timeDelta = _decodeTimeDelta(hBs, Z);
+      if (k >= (16 - 1)) continue;
+      /* frameEndFlag == 1 needs special handling for last node with node
+       * reservoir */
+      nodeTimeTmp = timeOffs + timeDelta * deltaTmin;
+      if (nodeTimeTmp > frameSize + timeOffset) {
+        if (nodeResFlag == 0) {
+          pNodes[k].time = frameSize + timeOffset;
+          nodeResFlag = 1;
+        }
+        pNodes[k + 1].time = nodeTimeTmp;
+      } else {
+        pNodes[k].time = nodeTimeTmp;
+      }
+      timeOffs = nodeTimeTmp;
+    }
+    if (nodeResFlag == 0) {
+      k = fMin(k, 16 - 1);
+      pNodes[k].time = frameSize + timeOffset;
+    }
+  } else {
+    for (k = 0; k < nNodes; k++) {
+      /* decode a delta time value */
+      timeDelta = _decodeTimeDelta(hBs, Z);
+      if (k >= 16) continue;
+      pNodes[k].time = timeOffs + timeDelta * deltaTmin;
+      timeOffs = pNodes[k].time;
+    }
+  }
+}
+
+static void _readNodes(HANDLE_FDK_BITSTREAM hBs, GAIN_SET* gainSet,
+                       const int frameSize, const int timeDeltaMin,
+                       UCHAR* pNNodes, GAIN_NODE* pNodes) {
+  int timeOffset, drcGainCodingMode, nNodes;
+  int Z = _getZ(frameSize / timeDeltaMin);
+  if (gainSet->timeAlignment == 0) {
+    timeOffset = -1;
+  } else {
+    timeOffset = -timeDeltaMin +
+                 (timeDeltaMin - 1) /
+                     2; /* timeOffset = - deltaTmin + floor((deltaTmin-1)/2); */
+  }
+
+  drcGainCodingMode = FDKreadBits(hBs, 1);
+  if (drcGainCodingMode == 0) {
+    /* "simple" mode: only one node at the end of the frame with slope = 0 */
+    nNodes = 1;
+    pNodes[0].gainDb = _decodeGainInitial(
+        hBs, (GAIN_CODING_PROFILE)gainSet->gainCodingProfile);
+    pNodes[0].time = frameSize + timeOffset;
+  } else {
+    nNodes = _decodeNNodes(hBs);
+
+    _decodeSlopes(hBs, (GAIN_INTERPOLATION_TYPE)gainSet->gainInterpolationType,
+                  nNodes, pNodes);
+
+    _decodeTimes(hBs, timeDeltaMin, frameSize, gainSet->fullFrame, timeOffset,
+                 Z, nNodes, pNodes);
+
+    _decodeGains(hBs, (GAIN_CODING_PROFILE)gainSet->gainCodingProfile, nNodes,
+                 pNodes);
+  }
+  *pNNodes = (UCHAR)nNodes;
+}
+
+static void _readDrcGainSequence(HANDLE_FDK_BITSTREAM hBs, GAIN_SET* gainSet,
+                                 const int frameSize, const int timeDeltaMin,
+                                 UCHAR* pNNodes, GAIN_NODE pNodes[16]) {
+  SHORT timeBufPrevFrame[16], timeBufCurFrame[16];
+  int nNodesNodeRes, nNodesCur, k, m;
+
+  if (gainSet->gainCodingProfile == GCP_CONSTANT) {
+    *pNNodes = 1;
+    pNodes[0].time = frameSize - 1;
+    pNodes[0].gainDb = (FIXP_SGL)0;
+  } else {
+    _readNodes(hBs, gainSet, frameSize, timeDeltaMin, pNNodes, pNodes);
+
+    /* count number of nodes in node reservoir */
+    nNodesNodeRes = 0;
+    nNodesCur = 0;
+    /* count and buffer nodes from node reservoir */
+    for (k = 0; k < *pNNodes; k++) {
+      if (k >= 16) continue;
+      if (pNodes[k].time >= frameSize) {
+        /* write node reservoir times into buffer */
+        timeBufPrevFrame[nNodesNodeRes] = pNodes[k].time;
+        nNodesNodeRes++;
+      } else { /* times from current frame */
+        timeBufCurFrame[nNodesCur] = pNodes[k].time;
+        nNodesCur++;
+      }
+    }
+    /* compose right time order (bit reservoir first) */
+    for (k = 0; k < nNodesNodeRes; k++) {
+      /* subtract two time frameSize: one to remove node reservoir offset and
+       * one to get the negative index relative to the current frame
+       */
+      pNodes[k].time = timeBufPrevFrame[k] - 2 * frameSize;
+    }
+    /* ...and times from current frame */
+    for (m = 0; m < nNodesCur; m++, k++) {
+      pNodes[k].time = timeBufCurFrame[m];
+    }
+  }
+}
+
+static DRC_ERROR _readUniDrcGainExtension(HANDLE_FDK_BITSTREAM hBs,
+                                          UNI_DRC_GAIN_EXTENSION* pExt) {
+  DRC_ERROR err = DE_OK;
+  int k, bitSizeLen, extSizeBits, bitSize;
+
+  k = 0;
+  pExt->uniDrcGainExtType[k] = FDKreadBits(hBs, 4);
+  while (pExt->uniDrcGainExtType[k] != UNIDRCGAINEXT_TERM) {
+    if (k >= (8 - 1)) return DE_MEMORY_ERROR;
+    bitSizeLen = FDKreadBits(hBs, 3);
+    extSizeBits = bitSizeLen + 4;
+
+    bitSize = FDKreadBits(hBs, extSizeBits);
+    pExt->extBitSize[k] = bitSize + 1;
+
+    switch (pExt->uniDrcGainExtType[k]) {
+      /* add future extensions here */
+      default:
+        FDKpushFor(hBs, pExt->extBitSize[k]);
+        break;
+    }
+    k++;
+    pExt->uniDrcGainExtType[k] = FDKreadBits(hBs, 4);
+  }
+
+  return err;
+}
+
+DRC_ERROR
+drcDec_readUniDrcGain(HANDLE_FDK_BITSTREAM hBs,
+                      HANDLE_UNI_DRC_CONFIG hUniDrcConfig, const int frameSize,
+                      const int deltaTminDefault,
+                      HANDLE_UNI_DRC_GAIN hUniDrcGain) {
+  DRC_ERROR err = DE_OK;
+  int seq, gainSequenceCount;
+  DRC_COEFFICIENTS_UNI_DRC* pCoef =
+      selectDrcCoefficients(hUniDrcConfig, LOCATION_SELECTED);
+  if (pCoef == NULL) return DE_OK;
+  if (hUniDrcGain == NULL) return DE_OK; /* hUniDrcGain not initialized yet */
+
+  gainSequenceCount = fMin(pCoef->gainSequenceCount, (UCHAR)12);
+
+  for (seq = 0; seq < gainSequenceCount; seq++) {
+    UCHAR index = pCoef->gainSetIndexForGainSequence[seq];
+    GAIN_SET* gainSet;
+    int timeDeltaMin;
+    UCHAR tmpNNodes = 0;
+    GAIN_NODE tmpNodes[16];
+
+    if ((index >= pCoef->gainSetCount) || (index >= 12)) return DE_NOT_OK;
+    gainSet = &(pCoef->gainSet[index]);
+
+    timeDeltaMin = _getTimeDeltaMin(gainSet, deltaTminDefault);
+
+    _readDrcGainSequence(hBs, gainSet, frameSize, timeDeltaMin, &tmpNNodes,
+                         tmpNodes);
+
+    hUniDrcGain->nNodes[seq] = tmpNNodes;
+    FDKmemcpy(hUniDrcGain->gainNode[seq], tmpNodes,
+              fMin(tmpNNodes, (UCHAR)16) * sizeof(GAIN_NODE));
+  }
+
+  hUniDrcGain->uniDrcGainExtPresent = FDKreadBits(hBs, 1);
+  if (hUniDrcGain->uniDrcGainExtPresent == 1) {
+    err = _readUniDrcGainExtension(hBs, &(hUniDrcGain->uniDrcGainExtension));
+    if (err) return err;
+  }
+
+  return err;
+}
+
+/****************/
+/* uniDrcConfig */
+/****************/
+
+static void _decodeDuckingModification(HANDLE_FDK_BITSTREAM hBs,
+                                       DUCKING_MODIFICATION* pDMod, int isBox) {
+  int bsDuckingScaling, sigma, mu;
+
+  if (isBox) FDKpushFor(hBs, 7); /* reserved */
+  pDMod->duckingScalingPresent = FDKreadBits(hBs, 1);
+
+  if (pDMod->duckingScalingPresent) {
+    if (isBox) FDKpushFor(hBs, 4); /* reserved */
+    bsDuckingScaling = FDKreadBits(hBs, 4);
+    sigma = bsDuckingScaling >> 3;
+    mu = bsDuckingScaling & 0x7;
+
+    if (sigma) {
+      pDMod->duckingScaling = (FIXP_SGL)(
+          (7 - mu) << (FRACT_BITS - 1 - 3 - 2)); /* 1.0 - 0.125 * (1 + mu); */
+    } else {
+      pDMod->duckingScaling = (FIXP_SGL)(
+          (9 + mu) << (FRACT_BITS - 1 - 3 - 2)); /* 1.0 + 0.125 * (1 + mu); */
+    }
+  } else {
+    pDMod->duckingScaling = (FIXP_SGL)(1 << (FRACT_BITS - 1 - 2)); /* 1.0 */
+  }
+}
+
+static void _decodeGainModification(HANDLE_FDK_BITSTREAM hBs, const int version,
+                                    int bandCount, GAIN_MODIFICATION* pGMod,
+                                    int isBox) {
+  int sign, bsGainOffset, bsAttenuationScaling, bsAmplificationScaling;
+
+  if (version > 0) {
+    int b, shapeFilterPresent;
+
+    if (isBox) {
+      FDKpushFor(hBs, 4); /* reserved */
+      bandCount = FDKreadBits(hBs, 4);
+    }
+
+    for (b = 0; b < bandCount; b++) {
+      if (isBox) {
+        FDKpushFor(hBs, 4); /* reserved */
+        pGMod[b].targetCharacteristicLeftPresent = FDKreadBits(hBs, 1);
+        pGMod[b].targetCharacteristicRightPresent = FDKreadBits(hBs, 1);
+        pGMod[b].gainScalingPresent = FDKreadBits(hBs, 1);
+        pGMod[b].gainOffsetPresent = FDKreadBits(hBs, 1);
+      }
+
+      if (!isBox)
+        pGMod[b].targetCharacteristicLeftPresent = FDKreadBits(hBs, 1);
+      if (pGMod[b].targetCharacteristicLeftPresent) {
+        if (isBox) FDKpushFor(hBs, 4); /* reserved */
+        pGMod[b].targetCharacteristicLeftIndex = FDKreadBits(hBs, 4);
+      }
+      if (!isBox)
+        pGMod[b].targetCharacteristicRightPresent = FDKreadBits(hBs, 1);
+      if (pGMod[b].targetCharacteristicRightPresent) {
+        if (isBox) FDKpushFor(hBs, 4); /* reserved */
+        pGMod[b].targetCharacteristicRightIndex = FDKreadBits(hBs, 4);
+      }
+      if (!isBox) pGMod[b].gainScalingPresent = FDKreadBits(hBs, 1);
+      if (pGMod[b].gainScalingPresent) {
+        bsAttenuationScaling = FDKreadBits(hBs, 4);
+        pGMod[b].attenuationScaling = (FIXP_SGL)(
+            bsAttenuationScaling
+            << (FRACT_BITS - 1 - 3 - 2)); /* bsAttenuationScaling * 0.125; */
+        bsAmplificationScaling = FDKreadBits(hBs, 4);
+        pGMod[b].amplificationScaling = (FIXP_SGL)(
+            bsAmplificationScaling
+            << (FRACT_BITS - 1 - 3 - 2)); /* bsAmplificationScaling * 0.125; */
+      }
+      if (!isBox) pGMod[b].gainOffsetPresent = FDKreadBits(hBs, 1);
+      if (pGMod[b].gainOffsetPresent) {
+        if (isBox) FDKpushFor(hBs, 2); /* reserved */
+        sign = FDKreadBits(hBs, 1);
+        bsGainOffset = FDKreadBits(hBs, 5);
+        pGMod[b].gainOffset = (FIXP_SGL)(
+            (1 + bsGainOffset)
+            << (FRACT_BITS - 1 - 2 - 4)); /* (1+bsGainOffset) * 0.25; */
+        if (sign) {
+          pGMod[b].gainOffset = -pGMod[b].gainOffset;
+        }
+      }
+    }
+    if (bandCount == 1) {
+      shapeFilterPresent = FDKreadBits(hBs, 1);
+      if (shapeFilterPresent) {
+        if (isBox) FDKpushFor(hBs, 3); /* reserved */
+        FDKpushFor(hBs, 4);            /* pGMod->shapeFilterIndex */
+      } else {
+        if (isBox) FDKpushFor(hBs, 7); /* reserved */
+      }
+    }
+  } else {
+    int b, gainScalingPresent, gainOffsetPresent;
+    FIXP_SGL attenuationScaling = FL2FXCONST_SGL(1.0f / (float)(1 << 2)),
+             amplificationScaling = FL2FXCONST_SGL(1.0f / (float)(1 << 2)),
+             gainOffset = (FIXP_SGL)0;
+    if (isBox) FDKpushFor(hBs, 7); /* reserved */
+    gainScalingPresent = FDKreadBits(hBs, 1);
+    if (gainScalingPresent) {
+      bsAttenuationScaling = FDKreadBits(hBs, 4);
+      attenuationScaling = (FIXP_SGL)(
+          bsAttenuationScaling
+          << (FRACT_BITS - 1 - 3 - 2)); /* bsAttenuationScaling * 0.125; */
+      bsAmplificationScaling = FDKreadBits(hBs, 4);
+      amplificationScaling = (FIXP_SGL)(
+          bsAmplificationScaling
+          << (FRACT_BITS - 1 - 3 - 2)); /* bsAmplificationScaling * 0.125; */
+    }
+    if (isBox) FDKpushFor(hBs, 7); /* reserved */
+    gainOffsetPresent = FDKreadBits(hBs, 1);
+    if (gainOffsetPresent) {
+      if (isBox) FDKpushFor(hBs, 2); /* reserved */
+      sign = FDKreadBits(hBs, 1);
+      bsGainOffset = FDKreadBits(hBs, 5);
+      gainOffset =
+          (FIXP_SGL)((1 + bsGainOffset) << (FRACT_BITS - 1 - 2 -
+                                            4)); /* (1+bsGainOffset) * 0.25; */
+      if (sign) {
+        gainOffset = -gainOffset;
+      }
+    }
+    for (b = 0; b < 4; b++) {
+      pGMod[b].targetCharacteristicLeftPresent = 0;
+      pGMod[b].targetCharacteristicRightPresent = 0;
+      pGMod[b].gainScalingPresent = gainScalingPresent;
+      pGMod[b].attenuationScaling = attenuationScaling;
+      pGMod[b].amplificationScaling = amplificationScaling;
+      pGMod[b].gainOffsetPresent = gainOffsetPresent;
+      pGMod[b].gainOffset = gainOffset;
+    }
+  }
+}
+
+static void _readDrcCharacteristic(HANDLE_FDK_BITSTREAM hBs, const int version,
+                                   DRC_CHARACTERISTIC* pDChar, int isBox) {
+  if (version == 0) {
+    if (isBox) FDKpushFor(hBs, 1); /* reserved */
+    pDChar->cicpIndex = FDKreadBits(hBs, 7);
+    if (pDChar->cicpIndex > 0) {
+      pDChar->present = 1;
+      pDChar->isCICP = 1;
+    } else {
+      pDChar->present = 0;
+    }
+  } else {
+    pDChar->present = FDKreadBits(hBs, 1);
+    if (isBox) pDChar->isCICP = FDKreadBits(hBs, 1);
+    if (pDChar->present) {
+      if (!isBox) pDChar->isCICP = FDKreadBits(hBs, 1);
+      if (pDChar->isCICP) {
+        if (isBox) FDKpushFor(hBs, 1); /* reserved */
+        pDChar->cicpIndex = FDKreadBits(hBs, 7);
+      } else {
+        pDChar->custom.left = FDKreadBits(hBs, 4);
+        pDChar->custom.right = FDKreadBits(hBs, 4);
+      }
+    }
+  }
+}
+
+static void _readBandBorder(HANDLE_FDK_BITSTREAM hBs, BAND_BORDER* pBBord,
+                            int drcBandType, int isBox) {
+  if (drcBandType) {
+    if (isBox) FDKpushFor(hBs, 4); /* reserved */
+    pBBord->crossoverFreqIndex = FDKreadBits(hBs, 4);
+  } else {
+    if (isBox) FDKpushFor(hBs, 6); /* reserved */
+    pBBord->startSubBandIndex = FDKreadBits(hBs, 10);
+  }
+}
+
+static DRC_ERROR _readGainSet(HANDLE_FDK_BITSTREAM hBs, const int version,
+                              int* gainSequenceIndex, GAIN_SET* pGSet,
+                              int isBox) {
+  if (isBox) FDKpushFor(hBs, 2); /* reserved */
+  pGSet->gainCodingProfile = FDKreadBits(hBs, 2);
+  pGSet->gainInterpolationType = FDKreadBits(hBs, 1);
+  pGSet->fullFrame = FDKreadBits(hBs, 1);
+  pGSet->timeAlignment = FDKreadBits(hBs, 1);
+  pGSet->timeDeltaMinPresent = FDKreadBits(hBs, 1);
+
+  if (pGSet->timeDeltaMinPresent) {
+    int bsTimeDeltaMin;
+    if (isBox) FDKpushFor(hBs, 5); /* reserved */
+    bsTimeDeltaMin = FDKreadBits(hBs, 11);
+    pGSet->timeDeltaMin = bsTimeDeltaMin + 1;
+  }
+
+  if (pGSet->gainCodingProfile != GCP_CONSTANT) {
+    int i;
+    if (isBox) FDKpushFor(hBs, 3); /* reserved */
+    pGSet->bandCount = FDKreadBits(hBs, 4);
+    if (pGSet->bandCount > 4) return DE_MEMORY_ERROR;
+
+    if ((pGSet->bandCount > 1) || isBox) {
+      pGSet->drcBandType = FDKreadBits(hBs, 1);
+    }
+
+    for (i = 0; i < pGSet->bandCount; i++) {
+      if (version == 0) {
+        *gainSequenceIndex = (*gainSequenceIndex) + 1;
+      } else {
+        int indexPresent;
+        indexPresent = (isBox) ? 1 : FDKreadBits(hBs, 1);
+        if (indexPresent) {
+          int bsIndex;
+          bsIndex = FDKreadBits(hBs, 6);
+          *gainSequenceIndex = bsIndex;
+        } else {
+          *gainSequenceIndex = (*gainSequenceIndex) + 1;
+        }
+      }
+      pGSet->gainSequenceIndex[i] = *gainSequenceIndex;
+      _readDrcCharacteristic(hBs, version, &(pGSet->drcCharacteristic[i]),
+                             isBox);
+    }
+    for (i = 1; i < pGSet->bandCount; i++) {
+      _readBandBorder(hBs, &(pGSet->bandBorder[i]), pGSet->drcBandType, isBox);
+    }
+  } else {
+    pGSet->bandCount = 1;
+    *gainSequenceIndex = (*gainSequenceIndex) + 1;
+    pGSet->gainSequenceIndex[0] = *gainSequenceIndex;
+  }
+
+  return DE_OK;
+}
+
+static DRC_ERROR _readCustomDrcCharacteristic(HANDLE_FDK_BITSTREAM hBs,
+                                              const CHARACTERISTIC_SIDE side,
+                                              UCHAR* pCharacteristicFormat,
+                                              CUSTOM_DRC_CHAR* pCChar,
+                                              int isBox) {
+  if (isBox) FDKpushFor(hBs, 7); /* reserved */
+  *pCharacteristicFormat = FDKreadBits(hBs, 1);
+  if (*pCharacteristicFormat == CF_SIGMOID) {
+    int bsGain, bsIoRatio, bsExp;
+    if (isBox) FDKpushFor(hBs, 1); /* reserved */
+    bsGain = FDKreadBits(hBs, 6);
+    if (side == CS_LEFT) {
+      pCChar->sigmoid.gain = (FIXP_SGL)(bsGain << (FRACT_BITS - 1 - 6));
+    } else {
+      pCChar->sigmoid.gain = (FIXP_SGL)(-bsGain << (FRACT_BITS - 1 - 6));
+    }
+    bsIoRatio = FDKreadBits(hBs, 4);
+    /* pCChar->sigmoid.ioRatio = 0.05 + 0.15 * bsIoRatio; */
+    pCChar->sigmoid.ioRatio =
+        FL2FXCONST_SGL(0.05f / (float)(1 << 2)) +
+        (FIXP_SGL)((((3 * bsIoRatio) << (FRACT_BITS - 1)) / 5) >> 4);
+    bsExp = FDKreadBits(hBs, 4);
+    if (bsExp < 15) {
+      pCChar->sigmoid.exp = (FIXP_SGL)((1 + 2 * bsExp) << (FRACT_BITS - 1 - 5));
+    } else {
+      pCChar->sigmoid.exp = (FIXP_SGL)MAXVAL_SGL; /* represents infinity */
+    }
+    pCChar->sigmoid.flipSign = FDKreadBits(hBs, 1);
+  } else { /* CF_NODES */
+    int i, bsCharacteristicNodeCount, bsNodeLevelDelta, bsNodeGain;
+    if (isBox) FDKpushFor(hBs, 6); /* reserved */
+    bsCharacteristicNodeCount = FDKreadBits(hBs, 2);
+    pCChar->nodes.characteristicNodeCount = bsCharacteristicNodeCount + 1;
+    if (pCChar->nodes.characteristicNodeCount > 4) return DE_MEMORY_ERROR;
+    pCChar->nodes.nodeLevel[0] = DRC_INPUT_LOUDNESS_TARGET_SGL;
+    pCChar->nodes.nodeGain[0] = (FIXP_SGL)0;
+    for (i = 0; i < pCChar->nodes.characteristicNodeCount; i++) {
+      if (isBox) FDKpushFor(hBs, 3); /* reserved */
+      bsNodeLevelDelta = FDKreadBits(hBs, 5);
+      if (side == CS_LEFT) {
+        pCChar->nodes.nodeLevel[i + 1] =
+            pCChar->nodes.nodeLevel[i] -
+            (FIXP_SGL)((1 + bsNodeLevelDelta) << (FRACT_BITS - 1 - 7));
+      } else {
+        pCChar->nodes.nodeLevel[i + 1] =
+            pCChar->nodes.nodeLevel[i] +
+            (FIXP_SGL)((1 + bsNodeLevelDelta) << (FRACT_BITS - 1 - 7));
+      }
+      bsNodeGain = FDKreadBits(hBs, 8);
+      pCChar->nodes.nodeGain[i + 1] = (FIXP_SGL)(
+          (bsNodeGain - 128)
+          << (FRACT_BITS - 1 - 1 - 7)); /* 0.5f * bsNodeGain - 64.0f; */
+    }
+  }
+  return DE_OK;
+}
+
+static void _skipLoudEqInstructions(HANDLE_FDK_BITSTREAM hBs) {
+  int i;
+  int downmixIdPresent, additionalDownmixIdPresent,
+      additionalDownmixIdCount = 0;
+  int drcSetIdPresent, additionalDrcSetIdPresent, additionalDrcSetIdCount = 0;
+  int eqSetIdPresent, additionalEqSetIdPresent, additionalEqSetIdCount = 0;
+  int loudEqGainSequenceCount, drcCharacteristicFormatIsCICP;
+
+  FDKpushFor(hBs, 4); /* loudEqSetId */
+  FDKpushFor(hBs, 4); /* drcLocation */
+  downmixIdPresent = FDKreadBits(hBs, 1);
+  if (downmixIdPresent) {
+    FDKpushFor(hBs, 7); /* downmixId */
+    additionalDownmixIdPresent = FDKreadBits(hBs, 1);
+    if (additionalDownmixIdPresent) {
+      additionalDownmixIdCount = FDKreadBits(hBs, 7);
+      for (i = 0; i < additionalDownmixIdCount; i++) {
+        FDKpushFor(hBs, 7); /* additionalDownmixId */
+      }
+    }
+  }
+
+  drcSetIdPresent = FDKreadBits(hBs, 1);
+  if (drcSetIdPresent) {
+    FDKpushFor(hBs, 6); /* drcSetId */
+    additionalDrcSetIdPresent = FDKreadBits(hBs, 1);
+    if (additionalDrcSetIdPresent) {
+      additionalDrcSetIdCount = FDKreadBits(hBs, 6);
+      for (i = 0; i < additionalDrcSetIdCount; i++) {
+        FDKpushFor(hBs, 6); /* additionalDrcSetId; */
+      }
+    }
+  }
+
+  eqSetIdPresent = FDKreadBits(hBs, 1);
+  if (eqSetIdPresent) {
+    FDKpushFor(hBs, 6); /* eqSetId */
+    additionalEqSetIdPresent = FDKreadBits(hBs, 1);
+    if (additionalEqSetIdPresent) {
+      additionalEqSetIdCount = FDKreadBits(hBs, 6);
+      for (i = 0; i < additionalEqSetIdCount; i++) {
+        FDKpushFor(hBs, 6); /* additionalEqSetId; */
+      }
+    }
+  }
+
+  FDKpushFor(hBs, 1); /* loudnessAfterDrc */
+  FDKpushFor(hBs, 1); /* loudnessAfterEq */
+  loudEqGainSequenceCount = FDKreadBits(hBs, 6);
+  for (i = 0; i < loudEqGainSequenceCount; i++) {
+    FDKpushFor(hBs, 6); /* gainSequenceIndex */
+    drcCharacteristicFormatIsCICP = FDKreadBits(hBs, 1);
+    if (drcCharacteristicFormatIsCICP) {
+      FDKpushFor(hBs, 7); /* drcCharacteristic */
+    } else {
+      FDKpushFor(hBs, 4); /* drcCharacteristicLeftIndex */
+      FDKpushFor(hBs, 4); /* drcCharacteristicRightIndex */
+    }
+    FDKpushFor(hBs, 6); /* frequencyRangeIndex */
+    FDKpushFor(hBs, 3); /* bsLoudEqScaling */
+    FDKpushFor(hBs, 5); /* bsLoudEqOffset */
+  }
+}
+
+static void _skipEqSubbandGainSpline(HANDLE_FDK_BITSTREAM hBs) {
+  int nEqNodes, k, bits;
+  nEqNodes = FDKreadBits(hBs, 5);
+  nEqNodes += 2;
+  for (k = 0; k < nEqNodes; k++) {
+    bits = FDKreadBits(hBs, 1);
+    if (!bits) {
+      FDKpushFor(hBs, 4);
+    }
+  }
+  FDKpushFor(hBs, 4 * (nEqNodes - 1));
+  bits = FDKreadBits(hBs, 2);
+  switch (bits) {
+    case 0:
+      FDKpushFor(hBs, 5);
+      break;
+    case 1:
+    case 2:
+      FDKpushFor(hBs, 4);
+      break;
+    case 3:
+      FDKpushFor(hBs, 3);
+      break;
+  }
+  FDKpushFor(hBs, 5 * (nEqNodes - 1));
+}
+
+static void _skipEqCoefficients(HANDLE_FDK_BITSTREAM hBs) {
+  int j, k;
+  int eqDelayMaxPresent;
+  int uniqueFilterBlockCount, filterElementCount, filterElementGainPresent;
+  int uniqueTdFilterElementCount, eqFilterFormat, bsRealZeroRadiusOneCount,
+      realZeroCount, genericZeroCount, realPoleCount, complexPoleCount,
+      firFilterOrder;
+  int uniqueEqSubbandGainsCount, eqSubbandGainRepresentation,
+      eqSubbandGainCount;
+  EQ_SUBBAND_GAIN_FORMAT eqSubbandGainFormat;
+
+  eqDelayMaxPresent = FDKreadBits(hBs, 1);
+  if (eqDelayMaxPresent) {
+    FDKpushFor(hBs, 8); /* bsEqDelayMax */
+  }
+
+  uniqueFilterBlockCount = FDKreadBits(hBs, 6);
+  for (j = 0; j < uniqueFilterBlockCount; j++) {
+    filterElementCount = FDKreadBits(hBs, 6);
+    for (k = 0; k < filterElementCount; k++) {
+      FDKpushFor(hBs, 6); /* filterElementIndex */
+      filterElementGainPresent = FDKreadBits(hBs, 1);
+      if (filterElementGainPresent) {
+        FDKpushFor(hBs, 10); /* bsFilterElementGain */
+      }
+    }
+  }
+  uniqueTdFilterElementCount = FDKreadBits(hBs, 6);
+  for (j = 0; j < uniqueTdFilterElementCount; j++) {
+    eqFilterFormat = FDKreadBits(hBs, 1);
+    if (eqFilterFormat == 0) { /* pole/zero */
+      bsRealZeroRadiusOneCount = FDKreadBits(hBs, 3);
+      realZeroCount = FDKreadBits(hBs, 6);
+      genericZeroCount = FDKreadBits(hBs, 6);
+      realPoleCount = FDKreadBits(hBs, 4);
+      complexPoleCount = FDKreadBits(hBs, 4);
+      FDKpushFor(hBs, 2 * bsRealZeroRadiusOneCount * 1);
+      FDKpushFor(hBs, realZeroCount * 8);
+      FDKpushFor(hBs, genericZeroCount * 14);
+      FDKpushFor(hBs, realPoleCount * 8);
+      FDKpushFor(hBs, complexPoleCount * 14);
+    } else { /* FIR coefficients */
+      firFilterOrder = FDKreadBits(hBs, 7);
+      FDKpushFor(hBs, 1);
+      FDKpushFor(hBs, (firFilterOrder / 2 + 1) * 11);
+    }
+  }
+  uniqueEqSubbandGainsCount = FDKreadBits(hBs, 6);
+  if (uniqueEqSubbandGainsCount > 0) {
+    eqSubbandGainRepresentation = FDKreadBits(hBs, 1);
+    eqSubbandGainFormat = (EQ_SUBBAND_GAIN_FORMAT)FDKreadBits(hBs, 4);
+    switch (eqSubbandGainFormat) {
+      case GF_QMF32:
+        eqSubbandGainCount = 32;
+        break;
+      case GF_QMFHYBRID39:
+        eqSubbandGainCount = 39;
+        break;
+      case GF_QMF64:
+        eqSubbandGainCount = 64;
+        break;
+      case GF_QMFHYBRID71:
+        eqSubbandGainCount = 71;
+        break;
+      case GF_QMF128:
+        eqSubbandGainCount = 128;
+        break;
+      case GF_QMFHYBRID135:
+        eqSubbandGainCount = 135;
+        break;
+      case GF_UNIFORM:
+      default:
+        eqSubbandGainCount = FDKreadBits(hBs, 8);
+        eqSubbandGainCount++;
+        break;
+    }
+    for (k = 0; k < uniqueEqSubbandGainsCount; k++) {
+      if (eqSubbandGainRepresentation == 1) {
+        _skipEqSubbandGainSpline(hBs);
+      } else {
+        FDKpushFor(hBs, eqSubbandGainCount * 9);
+      }
+    }
+  }
+}
+
+static void _skipTdFilterCascade(HANDLE_FDK_BITSTREAM hBs,
+                                 const int eqChannelGroupCount) {
+  int i, eqCascadeGainPresent, filterBlockCount, eqPhaseAlignmentPresent;
+  for (i = 0; i < eqChannelGroupCount; i++) {
+    eqCascadeGainPresent = FDKreadBits(hBs, 1);
+    if (eqCascadeGainPresent) {
+      FDKpushFor(hBs, 10); /* bsEqCascadeGain */
+    }
+    filterBlockCount = FDKreadBits(hBs, 4);
+    FDKpushFor(hBs, filterBlockCount * 7); /* filterBlockIndex */
+  }
+  eqPhaseAlignmentPresent = FDKreadBits(hBs, 1);
+  {
+    if (eqPhaseAlignmentPresent) {
+      for (i = 0; i < eqChannelGroupCount; i++) {
+        FDKpushFor(hBs, (eqChannelGroupCount - i - 1) * 1);
+      }
+    }
+  }
+}
+
+static DRC_ERROR _skipEqInstructions(HANDLE_FDK_BITSTREAM hBs,
+                                     HANDLE_UNI_DRC_CONFIG hUniDrcConfig) {
+  DRC_ERROR err = DE_OK;
+  int c, i, k, channelCount;
+  int downmixIdPresent, downmixId, eqApplyToDownmix, additionalDownmixIdPresent,
+      additionalDownmixIdCount = 0;
+  int additionalDrcSetIdPresent, additionalDrcSetIdCount;
+  int dependsOnEqSetPresent, eqChannelGroupCount, tdFilterCascadePresent,
+      subbandGainsPresent, eqTransitionDurationPresent;
+
+  FDKpushFor(hBs, 6); /* eqSetId */
+  FDKpushFor(hBs, 4); /* eqSetComplexityLevel */
+  downmixIdPresent = FDKreadBits(hBs, 1);
+  if (downmixIdPresent) {
+    downmixId = FDKreadBits(hBs, 7);
+    eqApplyToDownmix = FDKreadBits(hBs, 1);
+    additionalDownmixIdPresent = FDKreadBits(hBs, 1);
+    if (additionalDownmixIdPresent) {
+      additionalDownmixIdCount = FDKreadBits(hBs, 7);
+      FDKpushFor(hBs, additionalDownmixIdCount * 7); /* additionalDownmixId */
+    }
+  } else {
+    downmixId = 0;
+    eqApplyToDownmix = 0;
+  }
+  FDKpushFor(hBs, 6); /* drcSetId */
+  additionalDrcSetIdPresent = FDKreadBits(hBs, 1);
+  if (additionalDrcSetIdPresent) {
+    additionalDrcSetIdCount = FDKreadBits(hBs, 6);
+    for (i = 0; i < additionalDrcSetIdCount; i++) {
+      FDKpushFor(hBs, 6); /* additionalDrcSetId */
+    }
+  }
+  FDKpushFor(hBs, 16); /* eqSetPurpose */
+  dependsOnEqSetPresent = FDKreadBits(hBs, 1);
+  if (dependsOnEqSetPresent) {
+    FDKpushFor(hBs, 6); /* dependsOnEqSet */
+  } else {
+    FDKpushFor(hBs, 1); /* noIndependentEqUse */
+  }
+
+  channelCount = hUniDrcConfig->channelLayout.baseChannelCount;
+  if ((downmixIdPresent == 1) && (eqApplyToDownmix == 1) && (downmixId != 0) &&
+      (downmixId != DOWNMIX_ID_ANY_DOWNMIX) &&
+      (additionalDownmixIdCount == 0)) {
+    DOWNMIX_INSTRUCTIONS* pDown =
+        selectDownmixInstructions(hUniDrcConfig, downmixId);
+    if (pDown == NULL) return DE_NOT_OK;
+
+    channelCount =
+        pDown->targetChannelCount; /* targetChannelCountFromDownmixId*/
+  } else if ((downmixId == DOWNMIX_ID_ANY_DOWNMIX) ||
+             (additionalDownmixIdCount > 1)) {
+    channelCount = 1;
+  }
+
+  eqChannelGroupCount = 0;
+  for (c = 0; c < channelCount; c++) {
+    UCHAR eqChannelGroupForChannel[8];
+    int newGroup = 1;
+    if (c >= 8) return DE_MEMORY_ERROR;
+    eqChannelGroupForChannel[c] = FDKreadBits(hBs, 7);
+    for (k = 0; k < c; k++) {
+      if (eqChannelGroupForChannel[c] == eqChannelGroupForChannel[k]) {
+        newGroup = 0;
+      }
+    }
+    if (newGroup == 1) {
+      eqChannelGroupCount += 1;
+    }
+  }
+  tdFilterCascadePresent = FDKreadBits(hBs, 1);
+  if (tdFilterCascadePresent) {
+    _skipTdFilterCascade(hBs, eqChannelGroupCount);
+  }
+  subbandGainsPresent = FDKreadBits(hBs, 1);
+  if (subbandGainsPresent) {
+    FDKpushFor(hBs, eqChannelGroupCount * 6); /* subbandGainsIndex */
+  }
+  eqTransitionDurationPresent = FDKreadBits(hBs, 1);
+  if (eqTransitionDurationPresent) {
+    FDKpushFor(hBs, 5); /* bsEqTransitionDuration */
+  }
+  return err;
+}
+
+static void _skipDrcCoefficientsBasic(HANDLE_FDK_BITSTREAM hBs) {
+  FDKpushFor(hBs, 4); /* drcLocation */
+  FDKpushFor(hBs, 7); /* drcCharacteristic */
+}
+
+static DRC_ERROR _readDrcCoefficientsUniDrc(HANDLE_FDK_BITSTREAM hBs,
+                                            const int version,
+                                            DRC_COEFFICIENTS_UNI_DRC* pCoef) {
+  DRC_ERROR err = DE_OK;
+  int i, bsDrcFrameSize;
+  int gainSequenceIndex = -1;
+
+  pCoef->drcLocation = FDKreadBits(hBs, 4);
+  pCoef->drcFrameSizePresent = FDKreadBits(hBs, 1);
+
+  if (pCoef->drcFrameSizePresent == 1) {
+    bsDrcFrameSize = FDKreadBits(hBs, 15);
+    pCoef->drcFrameSize = bsDrcFrameSize + 1;
+  }
+  if (version == 0) {
+    int gainSequenceCount = 0, gainSetCount;
+    pCoef->characteristicLeftCount = 0;
+    pCoef->characteristicRightCount = 0;
+    gainSetCount = FDKreadBits(hBs, 6);
+    pCoef->gainSetCount = fMin(gainSetCount, 12);
+    for (i = 0; i < gainSetCount; i++) {
+      GAIN_SET tmpGset;
+      FDKmemclear(&tmpGset, sizeof(GAIN_SET));
+      err = _readGainSet(hBs, version, &gainSequenceIndex, &tmpGset, 0);
+      if (err) return err;
+      gainSequenceCount += tmpGset.bandCount;
+
+      if (i >= 12) continue;
+      pCoef->gainSet[i] = tmpGset;
+    }
+    pCoef->gainSequenceCount = gainSequenceCount;
+  } else { /* (version == 1) */
+    UCHAR drcCharacteristicLeftPresent, drcCharacteristicRightPresent;
+    UCHAR shapeFiltersPresent, shapeFilterCount, tmpPresent;
+    int gainSetCount;
+    drcCharacteristicLeftPresent = FDKreadBits(hBs, 1);
+    if (drcCharacteristicLeftPresent) {
+      pCoef->characteristicLeftCount = FDKreadBits(hBs, 4);
+      if ((pCoef->characteristicLeftCount + 1) > 8) return DE_MEMORY_ERROR;
+      for (i = 0; i < pCoef->characteristicLeftCount; i++) {
+        err = _readCustomDrcCharacteristic(
+            hBs, CS_LEFT, &(pCoef->characteristicLeftFormat[i + 1]),
+            &(pCoef->customCharacteristicLeft[i + 1]), 0);
+        if (err) return err;
+      }
+    }
+    drcCharacteristicRightPresent = FDKreadBits(hBs, 1);
+    if (drcCharacteristicRightPresent) {
+      pCoef->characteristicRightCount = FDKreadBits(hBs, 4);
+      if ((pCoef->characteristicRightCount + 1) > 8) return DE_MEMORY_ERROR;
+      for (i = 0; i < pCoef->characteristicRightCount; i++) {
+        err = _readCustomDrcCharacteristic(
+            hBs, CS_RIGHT, &(pCoef->characteristicRightFormat[i + 1]),
+            &(pCoef->customCharacteristicRight[i + 1]), 0);
+        if (err) return err;
+      }
+    }
+    shapeFiltersPresent = FDKreadBits(hBs, 1);
+    if (shapeFiltersPresent) {
+      shapeFilterCount = FDKreadBits(hBs, 4);
+      for (i = 0; i < shapeFilterCount; i++) {
+        tmpPresent = FDKreadBits(hBs, 1);
+        if (tmpPresent) /* lfCutParams */
+          FDKpushFor(hBs, 5);
+
+        tmpPresent = FDKreadBits(hBs, 1);
+        if (tmpPresent) /* lfBoostParams */
+          FDKpushFor(hBs, 5);
+
+        tmpPresent = FDKreadBits(hBs, 1);
+        if (tmpPresent) /* hfCutParams */
+          FDKpushFor(hBs, 5);
+
+        tmpPresent = FDKreadBits(hBs, 1);
+        if (tmpPresent) /* hfBoostParams */
+          FDKpushFor(hBs, 5);
+      }
+    }
+    pCoef->gainSequenceCount = FDKreadBits(hBs, 6);
+    gainSetCount = FDKreadBits(hBs, 6);
+    pCoef->gainSetCount = fMin(gainSetCount, 12);
+    for (i = 0; i < gainSetCount; i++) {
+      GAIN_SET tmpGset;
+      FDKmemclear(&tmpGset, sizeof(GAIN_SET));
+      err = _readGainSet(hBs, version, &gainSequenceIndex, &tmpGset, 0);
+      if (err) return err;
+
+      if (i >= 12) continue;
+      pCoef->gainSet[i] = tmpGset;
+    }
+  }
+  for (i = 0; i < 12; i++) {
+    pCoef->gainSetIndexForGainSequence[i] = 255;
+  }
+  for (i = 0; i < pCoef->gainSetCount; i++) {
+    int b;
+    for (b = 0; b < pCoef->gainSet[i].bandCount; b++) {
+      if (pCoef->gainSet[i].gainSequenceIndex[b] >= 12) continue;
+      pCoef->gainSetIndexForGainSequence[pCoef->gainSet[i]
+                                             .gainSequenceIndex[b]] = i;
+    }
+  }
+
+  return err;
+}
+
+static void _skipDrcInstructionsBasic(HANDLE_FDK_BITSTREAM hBs) {
+  int drcSetEffect;
+  int additionalDownmixIdPresent, additionalDownmixIdCount,
+      limiterPeakTargetPresent;
+  int drcSetTargetLoudnessPresent, drcSetTargetLoudnessValueLowerPresent;
+
+  FDKpushFor(hBs, 6); /* drcSetId */
+  FDKpushFor(hBs, 4); /* drcLocation */
+  FDKpushFor(hBs, 7); /* downmixId */
+  additionalDownmixIdPresent = FDKreadBits(hBs, 1);
+  if (additionalDownmixIdPresent) {
+    additionalDownmixIdCount = FDKreadBits(hBs, 3);
+    FDKpushFor(hBs, 7 * additionalDownmixIdCount); /* additionalDownmixId */
+  }
+
+  drcSetEffect = FDKreadBits(hBs, 16);
+  if (!(drcSetEffect & (EB_DUCK_OTHER | EB_DUCK_SELF))) {
+    limiterPeakTargetPresent = FDKreadBits(hBs, 1);
+    if (limiterPeakTargetPresent) {
+      FDKpushFor(hBs, 8); /* bsLimiterPeakTarget */
+    }
+  }
+
+  drcSetTargetLoudnessPresent = FDKreadBits(hBs, 1);
+  if (drcSetTargetLoudnessPresent) {
+    FDKpushFor(hBs, 6); /* bsDrcSetTargetLoudnessValueUpper */
+    drcSetTargetLoudnessValueLowerPresent = FDKreadBits(hBs, 1);
+    if (drcSetTargetLoudnessValueLowerPresent) {
+      FDKpushFor(hBs, 6); /* bsDrcSetTargetLoudnessValueLower */
+    }
+  }
+}
+
+static DRC_ERROR _readDrcInstructionsUniDrc(HANDLE_FDK_BITSTREAM hBs,
+                                            const int version,
+                                            HANDLE_UNI_DRC_CONFIG hUniDrcConfig,
+                                            DRC_INSTRUCTIONS_UNI_DRC* pInst) {
+  DRC_ERROR err = DE_OK;
+  int i, g, c;
+  int downmixIdPresent, additionalDownmixIdPresent, additionalDownmixIdCount;
+  int bsLimiterPeakTarget, channelCount;
+  DRC_COEFFICIENTS_UNI_DRC* pCoef = NULL;
+  int repeatParameters, bsRepeatParametersCount;
+  int repeatSequenceIndex, bsRepeatSequenceCount;
+  SCHAR* gainSetIndex = pInst->gainSetIndex;
+  SCHAR channelGroupForChannel[8];
+  DUCKING_MODIFICATION duckingModificationForChannelGroup[8];
+
+  pInst->drcSetId = FDKreadBits(hBs, 6);
+  if (version == 0) {
+    /* Assume all v0 DRC sets to be manageable in terms of complexity */
+    pInst->drcSetComplexityLevel = 2;
+  } else {
+    pInst->drcSetComplexityLevel = FDKreadBits(hBs, 4);
+  }
+  pInst->drcLocation = FDKreadBits(hBs, 4);
+  if (version == 0) {
+    downmixIdPresent = 1;
+  } else {
+    downmixIdPresent = FDKreadBits(hBs, 1);
+  }
+  if (downmixIdPresent) {
+    pInst->downmixId[0] = FDKreadBits(hBs, 7);
+    if (version == 0) {
+      if (pInst->downmixId[0] == 0)
+        pInst->drcApplyToDownmix = 0;
+      else
+        pInst->drcApplyToDownmix = 1;
+    } else {
+      pInst->drcApplyToDownmix = FDKreadBits(hBs, 1);
+    }
+
+    additionalDownmixIdPresent = FDKreadBits(hBs, 1);
+    if (additionalDownmixIdPresent) {
+      additionalDownmixIdCount = FDKreadBits(hBs, 3);
+      if ((1 + additionalDownmixIdCount) > 8) return DE_MEMORY_ERROR;
+      for (i = 0; i < additionalDownmixIdCount; i++) {
+        pInst->downmixId[i + 1] = FDKreadBits(hBs, 7);
+      }
+      pInst->downmixIdCount = 1 + additionalDownmixIdCount;
+    } else {
+      pInst->downmixIdCount = 1;
+    }
+  } else {
+    pInst->downmixId[0] = 0;
+    pInst->downmixIdCount = 1;
+  }
+
+  pInst->drcSetEffect = FDKreadBits(hBs, 16);
+
+  if ((pInst->drcSetEffect & (EB_DUCK_OTHER | EB_DUCK_SELF)) == 0) {
+    pInst->limiterPeakTargetPresent = FDKreadBits(hBs, 1);
+    if (pInst->limiterPeakTargetPresent) {
+      bsLimiterPeakTarget = FDKreadBits(hBs, 8);
+      pInst->limiterPeakTarget = -(FIXP_SGL)(
+          bsLimiterPeakTarget
+          << (FRACT_BITS - 1 - 3 - 5)); /* - bsLimiterPeakTarget * 0.125; */
+    }
+  }
+
+  pInst->drcSetTargetLoudnessPresent = FDKreadBits(hBs, 1);
+
+  /* set default values */
+  pInst->drcSetTargetLoudnessValueUpper = 0;
+  pInst->drcSetTargetLoudnessValueLower = -63;
+
+  if (pInst->drcSetTargetLoudnessPresent == 1) {
+    int bsDrcSetTargetLoudnessValueUpper, bsDrcSetTargetLoudnessValueLower;
+    int drcSetTargetLoudnessValueLowerPresent;
+    bsDrcSetTargetLoudnessValueUpper = FDKreadBits(hBs, 6);
+    pInst->drcSetTargetLoudnessValueUpper =
+        bsDrcSetTargetLoudnessValueUpper - 63;
+    drcSetTargetLoudnessValueLowerPresent = FDKreadBits(hBs, 1);
+    if (drcSetTargetLoudnessValueLowerPresent == 1) {
+      bsDrcSetTargetLoudnessValueLower = FDKreadBits(hBs, 6);
+      pInst->drcSetTargetLoudnessValueLower =
+          bsDrcSetTargetLoudnessValueLower - 63;
+    }
+  }
+
+  pInst->dependsOnDrcSetPresent = FDKreadBits(hBs, 1);
+
+  pInst->noIndependentUse = 0;
+  if (pInst->dependsOnDrcSetPresent) {
+    pInst->dependsOnDrcSet = FDKreadBits(hBs, 6);
+  } else {
+    pInst->noIndependentUse = FDKreadBits(hBs, 1);
+  }
+
+  if (version == 0) {
+    pInst->requiresEq = 0;
+  } else {
+    pInst->requiresEq = FDKreadBits(hBs, 1);
+  }
+
+  pCoef = selectDrcCoefficients(hUniDrcConfig, pInst->drcLocation);
+
+  pInst->drcChannelCount = channelCount =
+      hUniDrcConfig->channelLayout.baseChannelCount;
+
+  if (pInst->drcSetEffect & (EB_DUCK_OTHER | EB_DUCK_SELF)) {
+    DUCKING_MODIFICATION* pDModForChannel =
+        pInst->duckingModificationForChannel;
+    c = 0;
+    while (c < channelCount) {
+      int bsGainSetIndex;
+      bsGainSetIndex = FDKreadBits(hBs, 6);
+      if (c >= 8) return DE_MEMORY_ERROR;
+      gainSetIndex[c] = bsGainSetIndex - 1;
+      _decodeDuckingModification(hBs, &(pDModForChannel[c]), 0);
+
+      c++;
+      repeatParameters = FDKreadBits(hBs, 1);
+      if (repeatParameters == 1) {
+        bsRepeatParametersCount = FDKreadBits(hBs, 5);
+        bsRepeatParametersCount += 1;
+        for (i = 0; i < bsRepeatParametersCount; i++) {
+          if (c >= 8) return DE_MEMORY_ERROR;
+          gainSetIndex[c] = gainSetIndex[c - 1];
+          pDModForChannel[c] = pDModForChannel[c - 1];
+          c++;
+        }
+      }
+    }
+    if (c > channelCount) {
+      return DE_NOT_OK;
+    }
+
+    err = deriveDrcChannelGroups(
+        pInst->drcSetEffect, pInst->drcChannelCount, gainSetIndex,
+        pDModForChannel, &pInst->nDrcChannelGroups,
+        pInst->gainSetIndexForChannelGroup, channelGroupForChannel,
+        duckingModificationForChannelGroup);
+    if (err) return (err);
+  } else {
+    int deriveChannelCount = 0;
+    if (((version == 0) || (pInst->drcApplyToDownmix != 0)) &&
+        (pInst->downmixId[0] != DOWNMIX_ID_BASE_LAYOUT) &&
+        (pInst->downmixId[0] != DOWNMIX_ID_ANY_DOWNMIX) &&
+        (pInst->downmixIdCount == 1)) {
+      if (hUniDrcConfig->downmixInstructionsCount != 0) {
+        DOWNMIX_INSTRUCTIONS* pDown =
+            selectDownmixInstructions(hUniDrcConfig, pInst->downmixId[0]);
+        if (pDown == NULL) return DE_NOT_OK;
+        pInst->drcChannelCount = channelCount =
+            pDown->targetChannelCount; /* targetChannelCountFromDownmixId*/
+      } else {
+        deriveChannelCount = 1;
+        channelCount = 1;
+      }
+    } else if (((version == 0) || (pInst->drcApplyToDownmix != 0)) &&
+               ((pInst->downmixId[0] == DOWNMIX_ID_ANY_DOWNMIX) ||
+                (pInst->downmixIdCount > 1))) {
+      /* Set maximum channel count as upper border. The effective channel count
+       * is set at the process function. */
+      pInst->drcChannelCount = 8;
+      channelCount = 1;
+    }
+
+    c = 0;
+    while (c < channelCount) {
+      int bsGainSetIndex;
+      bsGainSetIndex = FDKreadBits(hBs, 6);
+      if (c >= 8) return DE_MEMORY_ERROR;
+      gainSetIndex[c] = bsGainSetIndex - 1;
+      c++;
+      repeatSequenceIndex = FDKreadBits(hBs, 1);
+
+      if (repeatSequenceIndex == 1) {
+        bsRepeatSequenceCount = FDKreadBits(hBs, 5);
+        bsRepeatSequenceCount += 1;
+        if (deriveChannelCount) {
+          channelCount = 1 + bsRepeatSequenceCount;
+        }
+        for (i = 0; i < bsRepeatSequenceCount; i++) {
+          if (c >= 8) return DE_MEMORY_ERROR;
+          gainSetIndex[c] = bsGainSetIndex - 1;
+          c++;
+        }
+      }
+    }
+    if (c > channelCount) {
+      return DE_NOT_OK;
+    }
+    if (deriveChannelCount) {
+      pInst->drcChannelCount = channelCount;
+    }
+
+    /* DOWNMIX_ID_ANY_DOWNMIX: channelCount is 1. Distribute gainSetIndex to all
+     * channels. */
+    if ((pInst->downmixId[0] == DOWNMIX_ID_ANY_DOWNMIX) ||
+        (pInst->downmixIdCount > 1)) {
+      for (c = 1; c < pInst->drcChannelCount; c++) {
+        gainSetIndex[c] = gainSetIndex[0];
+      }
+    }
+
+    err = deriveDrcChannelGroups(pInst->drcSetEffect, pInst->drcChannelCount,
+                                 gainSetIndex, NULL, &pInst->nDrcChannelGroups,
+                                 pInst->gainSetIndexForChannelGroup,
+                                 channelGroupForChannel, NULL);
+    if (err) return (err);
+
+    for (g = 0; g < pInst->nDrcChannelGroups; g++) {
+      int set, bandCount;
+      set = pInst->gainSetIndexForChannelGroup[g];
+
+      /* get bandCount */
+      if (pCoef != NULL && set < pCoef->gainSetCount) {
+        bandCount = pCoef->gainSet[set].bandCount;
+      } else {
+        bandCount = 1;
+      }
+
+      _decodeGainModification(hBs, version, bandCount,
+                              pInst->gainModificationForChannelGroup[g], 0);
+    }
+  }
+
+  return err;
+}
+
+static DRC_ERROR _readChannelLayout(HANDLE_FDK_BITSTREAM hBs,
+                                    CHANNEL_LAYOUT* pChan) {
+  DRC_ERROR err = DE_OK;
+
+  pChan->baseChannelCount = FDKreadBits(hBs, 7);
+
+  if (pChan->baseChannelCount > 8) return DE_NOT_OK;
+
+  pChan->layoutSignalingPresent = FDKreadBits(hBs, 1);
+
+  if (pChan->layoutSignalingPresent) {
+    pChan->definedLayout = FDKreadBits(hBs, 8);
+
+    if (pChan->definedLayout == 0) {
+      int i;
+      for (i = 0; i < pChan->baseChannelCount; i++) {
+        if (i < 8) {
+          pChan->speakerPosition[i] = FDKreadBits(hBs, 7);
+        } else {
+          FDKpushFor(hBs, 7);
+        }
+      }
+    }
+  }
+  return err;
+}
+
+static DRC_ERROR _readDownmixInstructions(HANDLE_FDK_BITSTREAM hBs,
+                                          const int version,
+                                          CHANNEL_LAYOUT* pChan,
+                                          DOWNMIX_INSTRUCTIONS* pDown) {
+  DRC_ERROR err = DE_OK;
+
+  pDown->downmixId = FDKreadBits(hBs, 7);
+  pDown->targetChannelCount = FDKreadBits(hBs, 7);
+  pDown->targetLayout = FDKreadBits(hBs, 8);
+  pDown->downmixCoefficientsPresent = FDKreadBits(hBs, 1);
+
+  if (pDown->downmixCoefficientsPresent) {
+    int nDownmixCoeffs = pDown->targetChannelCount * pChan->baseChannelCount;
+    int i;
+    if (nDownmixCoeffs > 8 * 8) return DE_NOT_OK;
+    if (version == 0) {
+      pDown->bsDownmixOffset = 0;
+      for (i = 0; i < nDownmixCoeffs; i++) {
+        /* LFE downmix coefficients are not supported. */
+        pDown->downmixCoefficient[i] = downmixCoeff[FDKreadBits(hBs, 4)];
+      }
+    } else {
+      pDown->bsDownmixOffset = FDKreadBits(hBs, 4);
+      for (i = 0; i < nDownmixCoeffs; i++) {
+        pDown->downmixCoefficient[i] = downmixCoeffV1[FDKreadBits(hBs, 5)];
+      }
+    }
+  }
+  return err;
+}
+
+static DRC_ERROR _readDrcExtensionV1(HANDLE_FDK_BITSTREAM hBs,
+                                     HANDLE_UNI_DRC_CONFIG hUniDrcConfig) {
+  DRC_ERROR err = DE_OK;
+  int downmixInstructionsV1Present;
+  int drcCoeffsAndInstructionsUniDrcV1Present;
+  int loudEqInstructionsPresent, loudEqInstructionsCount;
+  int eqPresent, eqInstructionsCount;
+  int i, offset;
+  int diff = hUniDrcConfig->diff;
+
+  downmixInstructionsV1Present = FDKreadBits(hBs, 1);
+  if (downmixInstructionsV1Present == 1) {
+    diff |= _compAssign(&hUniDrcConfig->downmixInstructionsCountV1,
+                        FDKreadBits(hBs, 7));
+    offset = hUniDrcConfig->downmixInstructionsCountV0;
+    hUniDrcConfig->downmixInstructionsCount = fMin(
+        (UCHAR)(offset + hUniDrcConfig->downmixInstructionsCountV1), (UCHAR)6);
+    for (i = 0; i < hUniDrcConfig->downmixInstructionsCountV1; i++) {
+      DOWNMIX_INSTRUCTIONS tmpDown;
+      FDKmemclear(&tmpDown, sizeof(DOWNMIX_INSTRUCTIONS));
+      err = _readDownmixInstructions(hBs, 1, &hUniDrcConfig->channelLayout,
+                                     &tmpDown);
+      if (err) return err;
+      if ((offset + i) >= 6) continue;
+      if (!diff)
+        diff |= (FDKmemcmp(&tmpDown,
+                           &(hUniDrcConfig->downmixInstructions[offset + i]),
+                           sizeof(DOWNMIX_INSTRUCTIONS)) != 0);
+      hUniDrcConfig->downmixInstructions[offset + i] = tmpDown;
+    }
+  } else {
+    diff |= _compAssign(&hUniDrcConfig->downmixInstructionsCountV1, 0);
+  }
+
+  drcCoeffsAndInstructionsUniDrcV1Present = FDKreadBits(hBs, 1);
+  if (drcCoeffsAndInstructionsUniDrcV1Present == 1) {
+    diff |= _compAssign(&hUniDrcConfig->drcCoefficientsUniDrcCountV1,
+                        FDKreadBits(hBs, 3));
+    offset = hUniDrcConfig->drcCoefficientsUniDrcCountV0;
+    hUniDrcConfig->drcCoefficientsUniDrcCount =
+        fMin((UCHAR)(offset + hUniDrcConfig->drcCoefficientsUniDrcCountV1),
+             (UCHAR)2);
+    for (i = 0; i < hUniDrcConfig->drcCoefficientsUniDrcCountV1; i++) {
+      DRC_COEFFICIENTS_UNI_DRC tmpCoef;
+      FDKmemclear(&tmpCoef, sizeof(DRC_COEFFICIENTS_UNI_DRC));
+      err = _readDrcCoefficientsUniDrc(hBs, 1, &tmpCoef);
+      if (err) return err;
+      if ((offset + i) >= 2) continue;
+      if (!diff)
+        diff |= (FDKmemcmp(&tmpCoef,
+                           &(hUniDrcConfig->drcCoefficientsUniDrc[offset + i]),
+                           sizeof(DRC_COEFFICIENTS_UNI_DRC)) != 0);
+      hUniDrcConfig->drcCoefficientsUniDrc[offset + i] = tmpCoef;
+    }
+
+    diff |= _compAssign(&hUniDrcConfig->drcInstructionsUniDrcCountV1,
+                        FDKreadBits(hBs, 6));
+    offset = hUniDrcConfig->drcInstructionsUniDrcCount;
+    hUniDrcConfig->drcInstructionsUniDrcCount =
+        fMin((UCHAR)(offset + hUniDrcConfig->drcInstructionsUniDrcCountV1),
+             (UCHAR)12);
+    for (i = 0; i < hUniDrcConfig->drcInstructionsUniDrcCount; i++) {
+      DRC_INSTRUCTIONS_UNI_DRC tmpInst;
+      FDKmemclear(&tmpInst, sizeof(DRC_INSTRUCTIONS_UNI_DRC));
+      err = _readDrcInstructionsUniDrc(hBs, 1, hUniDrcConfig, &tmpInst);
+      if (err) return err;
+      if ((offset + i) >= 12) continue;
+      if (!diff)
+        diff |= (FDKmemcmp(&tmpInst,
+                           &(hUniDrcConfig->drcInstructionsUniDrc[offset + i]),
+                           sizeof(DRC_INSTRUCTIONS_UNI_DRC)) != 0);
+      hUniDrcConfig->drcInstructionsUniDrc[offset + i] = tmpInst;
+    }
+  } else {
+    diff |= _compAssign(&hUniDrcConfig->drcCoefficientsUniDrcCountV1, 0);
+    diff |= _compAssign(&hUniDrcConfig->drcInstructionsUniDrcCountV1, 0);
+  }
+
+  loudEqInstructionsPresent = FDKreadBits(hBs, 1);
+  if (loudEqInstructionsPresent == 1) {
+    loudEqInstructionsCount = FDKreadBits(hBs, 4);
+    for (i = 0; i < loudEqInstructionsCount; i++) {
+      _skipLoudEqInstructions(hBs);
+    }
+  }
+
+  eqPresent = FDKreadBits(hBs, 1);
+  if (eqPresent == 1) {
+    _skipEqCoefficients(hBs);
+    eqInstructionsCount = FDKreadBits(hBs, 4);
+    for (i = 0; i < eqInstructionsCount; i++) {
+      _skipEqInstructions(hBs, hUniDrcConfig);
+    }
+  }
+
+  hUniDrcConfig->diff = diff;
+
+  return err;
+}
+
+static DRC_ERROR _readUniDrcConfigExtension(
+    HANDLE_FDK_BITSTREAM hBs, HANDLE_UNI_DRC_CONFIG hUniDrcConfig) {
+  DRC_ERROR err = DE_OK;
+  int k, bitSizeLen, extSizeBits, bitSize;
+  INT nBitsRemaining;
+  UNI_DRC_CONFIG_EXTENSION* pExt = &(hUniDrcConfig->uniDrcConfigExt);
+
+  k = 0;
+  pExt->uniDrcConfigExtType[k] = FDKreadBits(hBs, 4);
+  while (pExt->uniDrcConfigExtType[k] != UNIDRCCONFEXT_TERM) {
+    if (k >= (8 - 1)) return DE_MEMORY_ERROR;
+    bitSizeLen = FDKreadBits(hBs, 4);
+    extSizeBits = bitSizeLen + 4;
+
+    bitSize = FDKreadBits(hBs, extSizeBits);
+    pExt->extBitSize[k] = bitSize + 1;
+    nBitsRemaining = (INT)FDKgetValidBits(hBs);
+
+    switch (pExt->uniDrcConfigExtType[k]) {
+      case UNIDRCCONFEXT_V1:
+        err = _readDrcExtensionV1(hBs, hUniDrcConfig);
+        if (err) return err;
+        if (nBitsRemaining !=
+            ((INT)pExt->extBitSize[k] + (INT)FDKgetValidBits(hBs)))
+          return DE_NOT_OK;
+        break;
+      case UNIDRCCONFEXT_PARAM_DRC:
+      /* add future extensions here */
+      default:
+        FDKpushFor(hBs, pExt->extBitSize[k]);
+        break;
+    }
+    k++;
+    pExt->uniDrcConfigExtType[k] = FDKreadBits(hBs, 4);
+  }
+
+  return err;
+}
+
+DRC_ERROR
+drcDec_readUniDrcConfig(HANDLE_FDK_BITSTREAM hBs,
+                        HANDLE_UNI_DRC_CONFIG hUniDrcConfig) {
+  DRC_ERROR err = DE_OK;
+  int i, diff = 0;
+  int drcDescriptionBasicPresent, drcCoefficientsBasicCount,
+      drcInstructionsBasicCount;
+  CHANNEL_LAYOUT tmpChan;
+  FDKmemclear(&tmpChan, sizeof(CHANNEL_LAYOUT));
+  if (hUniDrcConfig == NULL) return DE_NOT_OK;
+
+  diff |= _compAssign(&hUniDrcConfig->sampleRatePresent, FDKreadBits(hBs, 1));
+
+  if (hUniDrcConfig->sampleRatePresent == 1) {
+    diff |=
+        _compAssign(&hUniDrcConfig->sampleRate, FDKreadBits(hBs, 18) + 1000);
+  }
+
+  diff |= _compAssign(&hUniDrcConfig->downmixInstructionsCountV0,
+                      FDKreadBits(hBs, 7));
+
+  drcDescriptionBasicPresent = FDKreadBits(hBs, 1);
+  if (drcDescriptionBasicPresent == 1) {
+    drcCoefficientsBasicCount = FDKreadBits(hBs, 3);
+    drcInstructionsBasicCount = FDKreadBits(hBs, 4);
+  } else {
+    drcCoefficientsBasicCount = 0;
+    drcInstructionsBasicCount = 0;
+  }
+
+  diff |= _compAssign(&hUniDrcConfig->drcCoefficientsUniDrcCountV0,
+                      FDKreadBits(hBs, 3));
+  diff |= _compAssign(&hUniDrcConfig->drcInstructionsUniDrcCountV0,
+                      FDKreadBits(hBs, 6));
+
+  err = _readChannelLayout(hBs, &tmpChan);
+  if (err) return err;
+
+  if (!diff)
+    diff |= (FDKmemcmp(&tmpChan, &hUniDrcConfig->channelLayout,
+                       sizeof(CHANNEL_LAYOUT)) != 0);
+  hUniDrcConfig->channelLayout = tmpChan;
+
+  hUniDrcConfig->downmixInstructionsCount =
+      fMin(hUniDrcConfig->downmixInstructionsCountV0, (UCHAR)6);
+  for (i = 0; i < hUniDrcConfig->downmixInstructionsCountV0; i++) {
+    DOWNMIX_INSTRUCTIONS tmpDown;
+    FDKmemclear(&tmpDown, sizeof(DOWNMIX_INSTRUCTIONS));
+    err = _readDownmixInstructions(hBs, 0, &hUniDrcConfig->channelLayout,
+                                   &tmpDown);
+    if (err) return err;
+    if (i >= 6) continue;
+    if (!diff)
+      diff |= (FDKmemcmp(&tmpDown, &(hUniDrcConfig->downmixInstructions[i]),
+                         sizeof(DOWNMIX_INSTRUCTIONS)) != 0);
+    hUniDrcConfig->downmixInstructions[i] = tmpDown;
+  }
+
+  for (i = 0; i < drcCoefficientsBasicCount; i++) {
+    _skipDrcCoefficientsBasic(hBs);
+  }
+  for (i = 0; i < drcInstructionsBasicCount; i++) {
+    _skipDrcInstructionsBasic(hBs);
+  }
+
+  hUniDrcConfig->drcCoefficientsUniDrcCount =
+      fMin(hUniDrcConfig->drcCoefficientsUniDrcCountV0, (UCHAR)2);
+  for (i = 0; i < hUniDrcConfig->drcCoefficientsUniDrcCountV0; i++) {
+    DRC_COEFFICIENTS_UNI_DRC tmpCoef;
+    FDKmemclear(&tmpCoef, sizeof(DRC_COEFFICIENTS_UNI_DRC));
+    err = _readDrcCoefficientsUniDrc(hBs, 0, &tmpCoef);
+    if (err) return err;
+    if (i >= 2) continue;
+    if (!diff)
+      diff |= (FDKmemcmp(&tmpCoef, &(hUniDrcConfig->drcCoefficientsUniDrc[i]),
+                         sizeof(DRC_COEFFICIENTS_UNI_DRC)) != 0);
+    hUniDrcConfig->drcCoefficientsUniDrc[i] = tmpCoef;
+  }
+
+  hUniDrcConfig->drcInstructionsUniDrcCount =
+      fMin(hUniDrcConfig->drcInstructionsUniDrcCountV0, (UCHAR)12);
+  for (i = 0; i < hUniDrcConfig->drcInstructionsUniDrcCountV0; i++) {
+    DRC_INSTRUCTIONS_UNI_DRC tmpInst;
+    FDKmemclear(&tmpInst, sizeof(DRC_INSTRUCTIONS_UNI_DRC));
+    err = _readDrcInstructionsUniDrc(hBs, 0, hUniDrcConfig, &tmpInst);
+    if (err) return err;
+    if (i >= 12) continue;
+    if (!diff)
+      diff |= (FDKmemcmp(&tmpInst, &(hUniDrcConfig->drcInstructionsUniDrc[i]),
+                         sizeof(DRC_INSTRUCTIONS_UNI_DRC)) != 0);
+    hUniDrcConfig->drcInstructionsUniDrc[i] = tmpInst;
+  }
+
+  diff |=
+      _compAssign(&hUniDrcConfig->uniDrcConfigExtPresent, FDKreadBits(hBs, 1));
+  hUniDrcConfig->diff = diff;
+
+  if (hUniDrcConfig->uniDrcConfigExtPresent == 1) {
+    err = _readUniDrcConfigExtension(hBs, hUniDrcConfig);
+    if (err) return err;
+  }
+
+  return err;
+}
+
+/*******************/
+/* loudnessInfoSet */
+/*******************/
+
+static DRC_ERROR _decodeMethodValue(HANDLE_FDK_BITSTREAM hBs,
+                                    const UCHAR methodDefinition,
+                                    FIXP_DBL* methodValue, INT isBox) {
+  int tmp;
+  FIXP_DBL val;
+  switch (methodDefinition) {
+    case MD_UNKNOWN_OTHER:
+    case MD_PROGRAM_LOUDNESS:
+    case MD_ANCHOR_LOUDNESS:
+    case MD_MAX_OF_LOUDNESS_RANGE:
+    case MD_MOMENTARY_LOUDNESS_MAX:
+    case MD_SHORT_TERM_LOUDNESS_MAX:
+      tmp = FDKreadBits(hBs, 8);
+      val = FL2FXCONST_DBL(-57.75f / (float)(1 << 7)) +
+            (FIXP_DBL)(
+                tmp << (DFRACT_BITS - 1 - 2 - 7)); /* -57.75 + tmp * 0.25; */
+      break;
+    case MD_LOUDNESS_RANGE:
+      tmp = FDKreadBits(hBs, 8);
+      if (tmp == 0)
+        val = (FIXP_DBL)0;
+      else if (tmp <= 128)
+        val = (FIXP_DBL)(tmp << (DFRACT_BITS - 1 - 2 - 7)); /* tmp * 0.25; */
+      else if (tmp <= 204) {
+        val = (FIXP_DBL)(tmp << (DFRACT_BITS - 1 - 1 - 7)) -
+              FL2FXCONST_DBL(32.0f / (float)(1 << 7)); /* 0.5 * tmp - 32.0f; */
+      } else {
+        /* downscale by 1 more bit to prevent overflow at intermediate result */
+        val = (FIXP_DBL)(tmp << (DFRACT_BITS - 1 - 8)) -
+              FL2FXCONST_DBL(134.0f / (float)(1 << 8)); /* tmp - 134.0; */
+        val <<= 1;
+      }
+      break;
+    case MD_MIXING_LEVEL:
+      tmp = FDKreadBits(hBs, isBox ? 8 : 5);
+      val = (FIXP_DBL)(tmp << (DFRACT_BITS - 1 - 7)) +
+            FL2FXCONST_DBL(80.0f / (float)(1 << 7)); /* tmp + 80.0; */
+      break;
+    case MD_ROOM_TYPE:
+      tmp = FDKreadBits(hBs, isBox ? 8 : 2);
+      val = (FIXP_DBL)(tmp << (DFRACT_BITS - 1 - 7)); /* tmp; */
+      break;
+    case MD_SHORT_TERM_LOUDNESS:
+      tmp = FDKreadBits(hBs, 8);
+      val = FL2FXCONST_DBL(-116.0f / (float)(1 << 7)) +
+            (FIXP_DBL)(
+                tmp << (DFRACT_BITS - 1 - 1 - 7)); /* -116.0 + tmp * 0.5; */
+      break;
+    default:
+      return DE_NOT_OK; /* invalid methodDefinition value */
+  }
+  *methodValue = val;
+  return DE_OK;
+}
+
+static DRC_ERROR _readLoudnessMeasurement(HANDLE_FDK_BITSTREAM hBs,
+                                          LOUDNESS_MEASUREMENT* pMeas) {
+  DRC_ERROR err = DE_OK;
+
+  pMeas->methodDefinition = FDKreadBits(hBs, 4);
+  err =
+      _decodeMethodValue(hBs, pMeas->methodDefinition, &pMeas->methodValue, 0);
+  if (err) return err;
+  pMeas->measurementSystem = FDKreadBits(hBs, 4);
+  pMeas->reliability = FDKreadBits(hBs, 2);
+
+  return err;
+}
+
+static DRC_ERROR _readLoudnessInfo(HANDLE_FDK_BITSTREAM hBs, const int version,
+                                   LOUDNESS_INFO* loudnessInfo) {
+  DRC_ERROR err = DE_OK;
+  int bsSamplePeakLevel, bsTruePeakLevel, i;
+  int measurementCount;
+
+  loudnessInfo->drcSetId = FDKreadBits(hBs, 6);
+  if (version >= 1) {
+    loudnessInfo->eqSetId = FDKreadBits(hBs, 6);
+  } else {
+    loudnessInfo->eqSetId = 0;
+  }
+  loudnessInfo->downmixId = FDKreadBits(hBs, 7);
+
+  loudnessInfo->samplePeakLevelPresent = FDKreadBits(hBs, 1);
+  if (loudnessInfo->samplePeakLevelPresent) {
+    bsSamplePeakLevel = FDKreadBits(hBs, 12);
+    if (bsSamplePeakLevel == 0) {
+      loudnessInfo->samplePeakLevelPresent = 0;
+      loudnessInfo->samplePeakLevel = (FIXP_DBL)0;
+    } else { /* 20.0 - bsSamplePeakLevel * 0.03125; */
+      loudnessInfo->samplePeakLevel =
+          FL2FXCONST_DBL(20.0f / (float)(1 << 7)) -
+          (FIXP_DBL)(bsSamplePeakLevel << (DFRACT_BITS - 1 - 5 - 7));
+    }
+  }
+
+  loudnessInfo->truePeakLevelPresent = FDKreadBits(hBs, 1);
+  if (loudnessInfo->truePeakLevelPresent) {
+    bsTruePeakLevel = FDKreadBits(hBs, 12);
+    if (bsTruePeakLevel == 0) {
+      loudnessInfo->truePeakLevelPresent = 0;
+      loudnessInfo->truePeakLevel = (FIXP_DBL)0;
+    } else {
+      loudnessInfo->truePeakLevel =
+          FL2FXCONST_DBL(20.0f / (float)(1 << 7)) -
+          (FIXP_DBL)(bsTruePeakLevel << (DFRACT_BITS - 1 - 5 - 7));
+    }
+    loudnessInfo->truePeakLevelMeasurementSystem = FDKreadBits(hBs, 4);
+    loudnessInfo->truePeakLevelReliability = FDKreadBits(hBs, 2);
+  }
+
+  measurementCount = FDKreadBits(hBs, 4);
+  loudnessInfo->measurementCount = fMin(measurementCount, 8);
+  for (i = 0; i < measurementCount; i++) {
+    LOUDNESS_MEASUREMENT tmpMeas;
+    FDKmemclear(&tmpMeas, sizeof(LOUDNESS_MEASUREMENT));
+    err = _readLoudnessMeasurement(hBs, &tmpMeas);
+    if (err) return err;
+    if (i >= 8) continue;
+    loudnessInfo->loudnessMeasurement[i] = tmpMeas;
+  }
+
+  return err;
+}
+
+static DRC_ERROR _readLoudnessInfoSetExtEq(
+    HANDLE_FDK_BITSTREAM hBs, HANDLE_LOUDNESS_INFO_SET hLoudnessInfoSet) {
+  DRC_ERROR err = DE_OK;
+  int i, offset;
+  int diff = hLoudnessInfoSet->diff;
+
+  diff |= _compAssign(&hLoudnessInfoSet->loudnessInfoAlbumCountV1,
+                      FDKreadBits(hBs, 6));
+  diff |=
+      _compAssign(&hLoudnessInfoSet->loudnessInfoCountV1, FDKreadBits(hBs, 6));
+
+  offset = hLoudnessInfoSet->loudnessInfoAlbumCountV0;
+  hLoudnessInfoSet->loudnessInfoAlbumCount = fMin(
+      (UCHAR)(offset + hLoudnessInfoSet->loudnessInfoAlbumCountV1), (UCHAR)12);
+  for (i = 0; i < hLoudnessInfoSet->loudnessInfoAlbumCountV1; i++) {
+    LOUDNESS_INFO tmpLoud;
+    FDKmemclear(&tmpLoud, sizeof(LOUDNESS_INFO));
+    err = _readLoudnessInfo(hBs, 1, &tmpLoud);
+    if (err) return err;
+    if ((offset + i) >= 12) continue;
+    if (!diff)
+      diff |= (FDKmemcmp(&tmpLoud,
+                         &(hLoudnessInfoSet->loudnessInfoAlbum[offset + i]),
+                         sizeof(LOUDNESS_INFO)) != 0);
+    hLoudnessInfoSet->loudnessInfoAlbum[offset + i] = tmpLoud;
+  }
+
+  offset = hLoudnessInfoSet->loudnessInfoCountV0;
+  hLoudnessInfoSet->loudnessInfoCount =
+      fMin((UCHAR)(offset + hLoudnessInfoSet->loudnessInfoCountV1), (UCHAR)12);
+  for (i = 0; i < hLoudnessInfoSet->loudnessInfoCountV1; i++) {
+    LOUDNESS_INFO tmpLoud;
+    FDKmemclear(&tmpLoud, sizeof(LOUDNESS_INFO));
+    err = _readLoudnessInfo(hBs, 1, &tmpLoud);
+    if (err) return err;
+    if ((offset + i) >= 12) continue;
+    if (!diff)
+      diff |=
+          (FDKmemcmp(&tmpLoud, &(hLoudnessInfoSet->loudnessInfo[offset + i]),
+                     sizeof(LOUDNESS_INFO)) != 0);
+    hLoudnessInfoSet->loudnessInfo[offset + i] = tmpLoud;
+  }
+  hLoudnessInfoSet->diff = diff;
+  return err;
+}
+
+static DRC_ERROR _readLoudnessInfoSetExtension(
+    HANDLE_FDK_BITSTREAM hBs, HANDLE_LOUDNESS_INFO_SET hLoudnessInfoSet) {
+  DRC_ERROR err = DE_OK;
+  int k, bitSizeLen, extSizeBits, bitSize;
+  INT nBitsRemaining;
+  LOUDNESS_INFO_SET_EXTENSION* pExt = &(hLoudnessInfoSet->loudnessInfoSetExt);
+
+  k = 0;
+  pExt->loudnessInfoSetExtType[k] = FDKreadBits(hBs, 4);
+  while (pExt->loudnessInfoSetExtType[k] != UNIDRCLOUDEXT_TERM) {
+    if (k >= (8 - 1)) return DE_MEMORY_ERROR;
+    bitSizeLen = FDKreadBits(hBs, 4);
+    extSizeBits = bitSizeLen + 4;
+
+    bitSize = FDKreadBits(hBs, extSizeBits);
+    pExt->extBitSize[k] = bitSize + 1;
+    nBitsRemaining = (INT)FDKgetValidBits(hBs);
+
+    switch (pExt->loudnessInfoSetExtType[k]) {
+      case UNIDRCLOUDEXT_EQ:
+        err = _readLoudnessInfoSetExtEq(hBs, hLoudnessInfoSet);
+        if (err) return err;
+        if (nBitsRemaining !=
+            ((INT)pExt->extBitSize[k] + (INT)FDKgetValidBits(hBs)))
+          return DE_NOT_OK;
+        break;
+      /* add future extensions here */
+      default:
+        FDKpushFor(hBs, pExt->extBitSize[k]);
+        break;
+    }
+    k++;
+    pExt->loudnessInfoSetExtType[k] = FDKreadBits(hBs, 4);
+  }
+
+  return err;
+}
+
+/* Parser for loundessInfoSet() */
+DRC_ERROR
+drcDec_readLoudnessInfoSet(HANDLE_FDK_BITSTREAM hBs,
+                           HANDLE_LOUDNESS_INFO_SET hLoudnessInfoSet) {
+  DRC_ERROR err = DE_OK;
+  int i, diff = 0;
+  if (hLoudnessInfoSet == NULL) return DE_NOT_OK;
+
+  diff |= _compAssign(&hLoudnessInfoSet->loudnessInfoAlbumCountV0,
+                      FDKreadBits(hBs, 6));
+  diff |=
+      _compAssign(&hLoudnessInfoSet->loudnessInfoCountV0, FDKreadBits(hBs, 6));
+
+  hLoudnessInfoSet->loudnessInfoAlbumCount =
+      fMin(hLoudnessInfoSet->loudnessInfoAlbumCountV0, (UCHAR)12);
+  for (i = 0; i < hLoudnessInfoSet->loudnessInfoAlbumCountV0; i++) {
+    LOUDNESS_INFO tmpLoud;
+    FDKmemclear(&tmpLoud, sizeof(LOUDNESS_INFO));
+    err = _readLoudnessInfo(hBs, 0, &tmpLoud);
+    if (err) return err;
+    if (i >= 12) continue;
+    if (!diff)
+      diff |= (FDKmemcmp(&tmpLoud, &(hLoudnessInfoSet->loudnessInfoAlbum[i]),
+                         sizeof(LOUDNESS_INFO)) != 0);
+    hLoudnessInfoSet->loudnessInfoAlbum[i] = tmpLoud;
+  }
+
+  hLoudnessInfoSet->loudnessInfoCount =
+      fMin(hLoudnessInfoSet->loudnessInfoCountV0, (UCHAR)12);
+  for (i = 0; i < hLoudnessInfoSet->loudnessInfoCountV0; i++) {
+    LOUDNESS_INFO tmpLoud;
+    FDKmemclear(&tmpLoud, sizeof(LOUDNESS_INFO));
+    err = _readLoudnessInfo(hBs, 0, &tmpLoud);
+    if (err) return err;
+    if (i >= 12) continue;
+    if (!diff)
+      diff |= (FDKmemcmp(&tmpLoud, &(hLoudnessInfoSet->loudnessInfo[i]),
+                         sizeof(LOUDNESS_INFO)) != 0);
+    hLoudnessInfoSet->loudnessInfo[i] = tmpLoud;
+  }
+
+  diff |= _compAssign(&hLoudnessInfoSet->loudnessInfoSetExtPresent,
+                      FDKreadBits(hBs, 1));
+  hLoudnessInfoSet->diff = diff;
+
+  if (hLoudnessInfoSet->loudnessInfoSetExtPresent) {
+    err = _readLoudnessInfoSetExtension(hBs, hLoudnessInfoSet);
+    if (err) return err;
+  }
+
+  return err;
+}