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.

7 files changed, 4418 insertions, 0 deletions

diff --git a/fdk-aac/libPCMutils/include/limiter.h b/fdk-aac/libPCMutils/include/limiter.h
new file mode 100644
index 0000000..fab7226
--- /dev/null
+++ b/fdk-aac/libPCMutils/include/limiter.h
@@ -0,0 +1,281 @@
+/* -----------------------------------------------------------------------------
+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
+----------------------------------------------------------------------------- */
+
+/**************************** PCM utility library ******************************
+
+   Author(s):   Matthias Neusinger
+
+   Description: Hard limiter for clipping prevention
+
+*******************************************************************************/
+
+#ifndef LIMITER_H
+#define LIMITER_H
+
+#include "common_fix.h"
+#include "FDK_audio.h"
+
+#define TDL_ATTACK_DEFAULT_MS (15)  /* default attack  time in ms */
+#define TDL_RELEASE_DEFAULT_MS (50) /* default release time in ms */
+
+#define TDL_GAIN_SCALING (15) /* scaling of gain value. */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct TDLimiter {
+  unsigned int attack;
+  FIXP_DBL attackConst, releaseConst;
+  unsigned int attackMs, releaseMs, maxAttackMs;
+  FIXP_DBL threshold;
+  unsigned int channels, maxChannels;
+  UINT sampleRate, maxSampleRate;
+  FIXP_DBL cor, max;
+  FIXP_DBL* maxBuf;
+  FIXP_DBL* delayBuf;
+  unsigned int maxBufIdx, delayBufIdx;
+  FIXP_DBL smoothState0;
+  FIXP_DBL minGain;
+
+  FIXP_DBL additionalGainPrev;
+  FIXP_DBL additionalGainFilterState;
+  FIXP_DBL additionalGainFilterState1;
+};
+
+typedef enum {
+  TDLIMIT_OK = 0,
+  TDLIMIT_UNKNOWN = -1,
+
+  __error_codes_start = -100,
+
+  TDLIMIT_INVALID_HANDLE,
+  TDLIMIT_INVALID_PARAMETER,
+
+  __error_codes_end
+} TDLIMITER_ERROR;
+
+struct TDLimiter;
+typedef struct TDLimiter* TDLimiterPtr;
+
+#define PCM_LIM LONG
+#define FIXP_DBL2PCM_LIM(x) (x)
+#define PCM_LIM2FIXP_DBL(x) (x)
+#define PCM_LIM_BITS 32
+#define FIXP_PCM_LIM FIXP_DBL
+
+#define SAMPLE_BITS_LIM DFRACT_BITS
+
+/******************************************************************************
+ * pcmLimiter_Reset                                                            *
+ * limiter: limiter handle                                                     *
+ * returns: error code                                                         *
+ ******************************************************************************/
+TDLIMITER_ERROR pcmLimiter_Reset(TDLimiterPtr limiter);
+
+/******************************************************************************
+ * pcmLimiter_Destroy                                                          *
+ * limiter: limiter handle                                                     *
+ * returns: error code                                                         *
+ ******************************************************************************/
+TDLIMITER_ERROR pcmLimiter_Destroy(TDLimiterPtr limiter);
+
+/******************************************************************************
+ * pcmLimiter_GetDelay                                                         *
+ * limiter: limiter handle                                                     *
+ * returns: exact delay caused by the limiter in samples per channel           *
+ ******************************************************************************/
+unsigned int pcmLimiter_GetDelay(TDLimiterPtr limiter);
+
+/******************************************************************************
+ * pcmLimiter_GetMaxGainReduction                                              *
+ * limiter: limiter handle                                                     *
+ * returns: maximum gain reduction in last processed block in dB               *
+ ******************************************************************************/
+INT pcmLimiter_GetMaxGainReduction(TDLimiterPtr limiter);
+
+/******************************************************************************
+ * pcmLimiter_SetNChannels                                                     *
+ * limiter:   limiter handle                                                   *
+ * nChannels: number of channels ( <= maxChannels specified on create)         *
+ * returns:   error code                                                       *
+ ******************************************************************************/
+TDLIMITER_ERROR pcmLimiter_SetNChannels(TDLimiterPtr limiter,
+                                        unsigned int nChannels);
+
+/******************************************************************************
+ * pcmLimiter_SetSampleRate                                                    *
+ * limiter:    limiter handle                                                  *
+ * sampleRate: sampling rate in Hz ( <= maxSampleRate specified on create)     *
+ * returns:    error code                                                      *
+ ******************************************************************************/
+TDLIMITER_ERROR pcmLimiter_SetSampleRate(TDLimiterPtr limiter, UINT sampleRate);
+
+/******************************************************************************
+ * pcmLimiter_SetAttack                                                        *
+ * limiter:    limiter handle                                                  *
+ * attackMs:   attack time in ms ( <= maxAttackMs specified on create)         *
+ * returns:    error code                                                      *
+ ******************************************************************************/
+TDLIMITER_ERROR pcmLimiter_SetAttack(TDLimiterPtr limiter,
+                                     unsigned int attackMs);
+
+/******************************************************************************
+ * pcmLimiter_SetRelease                                                       *
+ * limiter:    limiter handle                                                  *
+ * releaseMs:  release time in ms                                              *
+ * returns:    error code                                                      *
+ ******************************************************************************/
+TDLIMITER_ERROR pcmLimiter_SetRelease(TDLimiterPtr limiter,
+                                      unsigned int releaseMs);
+
+/******************************************************************************
+ * pcmLimiter_GetLibInfo                                                       *
+ * info:       pointer to an allocated and initialized LIB_INFO structure      *
+ * returns:    error code                                                      *
+ ******************************************************************************/
+TDLIMITER_ERROR pcmLimiter_GetLibInfo(LIB_INFO* info);
+
+#ifdef __cplusplus
+}
+#endif
+
+/******************************************************************************
+ * pcmLimiter_Create                                                           *
+ * maxAttackMs:   maximum and initial attack/lookahead time in milliseconds    *
+ * releaseMs:     release time in milliseconds (90% time constant)             *
+ * threshold:     limiting threshold                                           *
+ * maxChannels:   maximum and initial number of channels                       *
+ * maxSampleRate: maximum and initial sampling rate in Hz                      *
+ * returns:       limiter handle                                               *
+ ******************************************************************************/
+TDLimiterPtr pcmLimiter_Create(unsigned int maxAttackMs, unsigned int releaseMs,
+                               FIXP_DBL threshold, unsigned int maxChannels,
+                               UINT maxSampleRate);
+
+/******************************************************************************
+ * pcmLimiter_SetThreshold                                                     *
+ * limiter:    limiter handle                                                  *
+ * threshold:  limiter threshold                                               *
+ * returns:    error code                                                      *
+ ******************************************************************************/
+TDLIMITER_ERROR pcmLimiter_SetThreshold(TDLimiterPtr limiter,
+                                        FIXP_DBL threshold);
+
+/******************************************************************************
+ * pcmLimiter_Apply                                                            *
+ * limiter:    limiter handle                                                  *
+ * pGain :     pointer to gains to be applied to the signal before limiting,   *
+ *             which are downscaled by TDL_GAIN_SCALING bit.                   *
+ *             These gains are delayed by gain_delay, and smoothed.            *
+ *             Smoothing is done by a butterworth lowpass filter with a cutoff *
+ *             frequency which is fixed with respect to the sampling rate.     *
+ *             It is a substitute for the smoothing due to windowing and       *
+ *             overlap/add, if a gain is applied in frequency domain.          *
+ * gain_scale: pointer to scaling exponents to be applied to the signal before *
+ *             limiting, without delay and without smoothing                   *
+ * gain_size:  number of elements in pGain, currently restricted to 1          *
+ * gain_delay: delay [samples] with which the gains in pGain shall be applied  *
+ *             gain_delay <= nSamples                                          *
+ * samples:    input/output buffer containing interleaved samples              *
+ *             precision of output will be DFRACT_BITS-TDL_GAIN_SCALING bits   *
+ * nSamples:   number of samples per channel                                   *
+ * returns:    error code                                                      *
+ ******************************************************************************/
+TDLIMITER_ERROR pcmLimiter_Apply(TDLimiterPtr limiter, PCM_LIM* samplesIn,
+                                 INT_PCM* samplesOut, FIXP_DBL* pGain,
+                                 const INT* gain_scale, const UINT gain_size,
+                                 const UINT gain_delay, const UINT nSamples);
+
+#endif /* #ifndef LIMITER_H */
diff --git a/fdk-aac/libPCMutils/include/pcm_utils.h b/fdk-aac/libPCMutils/include/pcm_utils.h
new file mode 100644
index 0000000..073bcfc
--- /dev/null
+++ b/fdk-aac/libPCMutils/include/pcm_utils.h
@@ -0,0 +1,131 @@
+/* -----------------------------------------------------------------------------
+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
+----------------------------------------------------------------------------- */
+
+/**************************** PCM utility library ******************************
+
+   Author(s):   Alfonso Pino Garcia
+
+   Description: Functions that perform (de)interleaving combined with format
+change
+
+*******************************************************************************/
+
+#if !defined(PCM_UTILS_H)
+#define PCM_UTILS_H
+
+#include "common_fix.h"
+
+void FDK_interleave(const FIXP_DBL *RESTRICT pIn, LONG *RESTRICT pOut,
+                    const UINT channels, const UINT frameSize,
+                    const UINT length);
+void FDK_interleave(const FIXP_DBL *RESTRICT pIn, SHORT *RESTRICT pOut,
+                    const UINT channels, const UINT frameSize,
+                    const UINT length);
+void FDK_interleave(const FIXP_SGL *RESTRICT pIn, SHORT *RESTRICT pOut,
+                    const UINT channels, const UINT frameSize,
+                    const UINT length);
+
+void FDK_deinterleave(const LONG *RESTRICT pIn, SHORT *RESTRICT pOut,
+                      const UINT channels, const UINT frameSize,
+                      const UINT length);
+void FDK_deinterleave(const LONG *RESTRICT pIn, LONG *RESTRICT pOut,
+                      const UINT channels, const UINT frameSize,
+                      const UINT length);
+void FDK_deinterleave(const SHORT *RESTRICT pIn, SHORT *RESTRICT pOut,
+                      const UINT channels, const UINT frameSize,
+                      const UINT length);
+void FDK_deinterleave(const SHORT *RESTRICT pIn, LONG *RESTRICT pOut,
+                      const UINT channels, const UINT frameSize,
+                      const UINT length);
+#endif /* !defined(PCM_UTILS_H) */
diff --git a/fdk-aac/libPCMutils/include/pcmdmx_lib.h b/fdk-aac/libPCMutils/include/pcmdmx_lib.h
new file mode 100644
index 0000000..d37a851
--- /dev/null
+++ b/fdk-aac/libPCMutils/include/pcmdmx_lib.h
@@ -0,0 +1,460 @@
+/* -----------------------------------------------------------------------------
+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
+----------------------------------------------------------------------------- */
+
+/**************************** PCM utility library ******************************
+
+   Author(s):   Christian Griebel
+
+   Description:
+
+*******************************************************************************/
+
+/**
+ * \file   pcmdmx_lib.h
+ * \brief  FDK PCM audio mixdown library interface header file.
+
+ \page INTRO Introduction
+
+
+ \section SCOPE Scope
+
+ This document describes the high-level application interface and usage of the
+ FDK PCM audio mixdown module library developed by the Fraunhofer Institute for
+ Integrated Circuits (IIS). Depending on the library configuration, the module
+ can manipulate the number of audio channels of a given PCM signal. It can
+ create for example a two channel stereo audio signal from a given multi-channel
+ configuration (e.g. 5.1 channels).
+
+
+ \page ABBREV List of abbreviations
+
+  \li \b AAC - Advanced Audio Coding\n
+    Is an audio coding standard for lossy digital audio compression standardized
+ by ISO and IEC, as part of the MPEG-2 (ISO/IEC 13818-7:2006) and MPEG-4
+ (ISO/IEC 14496-3:2009) specifications.
+
+  \li \b DSE - Data Stream Element\n
+    A syntactical element of the MPEG-2/4 Advanced Audio Coding bitstream
+ standardized in ISO/IEC 14496-3:2009. It can convey any kind of data associated
+ to one program.
+
+  \li \b PCE - Program Config Element\n
+    A syntactical element of the MPEG-2/4 Advanced Audio Coding bitstream
+ standardized in ISO/IEC 14496-3:2009 that can define the stream configuration
+ for a single program. In addition it can comprise simple downmix meta data.
+
+ */
+
+#ifndef PCMDMX_LIB_H
+#define PCMDMX_LIB_H
+
+#include "machine_type.h"
+#include "common_fix.h"
+#include "FDK_audio.h"
+#include "FDK_bitstream.h"
+
+/**
+ *  \enum  PCMDMX_ERROR
+ *
+ *  Error codes that can be returned by module interface functions.
+ */
+typedef enum {
+  PCMDMX_OK = 0x0, /*!< No error happened. */
+  PCMDMX_UNSUPPORTED =
+      0x1, /*!< The requested feature/service is unavailable. This can
+                occur if the module was built for a wrong configuration.  */
+  pcm_dmx_fatal_error_start,
+  PCMDMX_OUT_OF_MEMORY, /*!< Not enough memory to set up an instance of the
+                           module.    */
+  pcm_dmx_fatal_error_end,
+
+  PCMDMX_INVALID_HANDLE,   /*!< The given instance handle is not valid.   */
+  PCMDMX_INVALID_ARGUMENT, /*!< One of the parameters handed over is invalid. */
+  PCMDMX_INVALID_CH_CONFIG, /*!< The given channel configuration is not
+                               supported and thus no processing was performed.
+                             */
+  PCMDMX_INVALID_MODE,  /*!< The set configuration/mode is not applicable.  */
+  PCMDMX_UNKNOWN_PARAM, /*!< The handed parameter is not known/supported. */
+  PCMDMX_UNABLE_TO_SET_PARAM, /*!< Unable to set the specific parameter. Most
+                                 probably the    value ist out of range.
+                               */
+  PCMDMX_CORRUPT_ANC_DATA,    /*!< The read ancillary data was corrupt.       */
+  PCMDMX_OUTPUT_BUFFER_TOO_SMALL /*!< The size of pcm output buffer is too
+                                    small.               */
+
+} PCMDMX_ERROR;
+
+/** Macro to identify fatal errors. */
+#define PCMDMX_IS_FATAL_ERROR(err)          \
+  ((((err) >= pcm_dmx_fatal_error_start) && \
+    ((err) <= pcm_dmx_fatal_error_end))     \
+       ? 1                                  \
+       : 0)
+
+/**
+ *  \enum  PCMDMX_PARAM
+ *
+ *  Modules dynamic runtime parameters that can be handed to function
+ * pcmDmx_SetParam() and pcmDmx_GetParam().
+ */
+typedef enum {
+  DMX_PROFILE_SETTING =
+      0x01, /*!< Defines which equations, coefficients and default/
+                 fallback values used for downmixing. See
+                 ::DMX_PROFILE_TYPE type for details.             */
+  DMX_BS_DATA_EXPIRY_FRAME =
+      0x10, /*!< The number of frames without new metadata that
+                 have to go by before the bitstream data expires.
+                 The value 0 disables expiry.                     */
+  DMX_BS_DATA_DELAY =
+      0x11, /*!< The number of delay frames of the output samples
+                 compared to the bitstream data.                  */
+  MIN_NUMBER_OF_OUTPUT_CHANNELS =
+      0x20, /*!< The minimum number of output channels. For all
+                 input configurations that have less than the given
+                 channels the module will modify the output
+                 automatically to obtain the given number of output
+                 channels. Mono signals will be duplicated. If more
+                 than two output channels are desired the module
+                 just adds empty channels. The parameter value must
+                 be either -1, 0, 1, 2, 6 or 8. If the value is
+                 greater than zero and exceeds the value of
+                 parameter ::MAX_NUMBER_OF_OUTPUT_CHANNELS the
+                 latter will be set to the same value. Both values
+                 -1 and 0 disable the feature.                    */
+  MAX_NUMBER_OF_OUTPUT_CHANNELS =
+      0x21, /*!< The maximum number of output channels. For all
+                 input configurations that have more than the given
+                 channels the module will apply a mixdown
+                 automatically to obtain the given number of output
+                 channels. The value must be either -1, 0, 1, 2, 6
+                 or 8. If it's greater than zero and lower or equal
+                 than the value of ::MIN_NUMBER_OF_OUTPUT_CHANNELS
+                 parameter the latter will be set to the same value.
+                 The values -1 and 0 disable the feature.         */
+  DMX_DUAL_CHANNEL_MODE =
+      0x30, /*!< Downmix mode for two channel audio data. See type
+                 ::DUAL_CHANNEL_MODE for details.                 */
+  DMX_PSEUDO_SURROUND_MODE =
+      0x31 /*!< Defines how module handles pseudo surround
+                compatible signals. See ::PSEUDO_SURROUND_MODE
+                type for details.                                */
+} PCMDMX_PARAM;
+
+/**
+ *  \enum  DMX_PROFILE_TYPE
+ *
+ *  Valid value list for parameter ::DMX_PROFILE_SETTING.
+ */
+typedef enum {
+  DMX_PRFL_STANDARD =
+      0x0, /*!< The standard profile creates mixdown signals based on
+                the advanced downmix metadata (from a DSE), equations
+                and default values defined in ISO/IEC 14496:3
+                Ammendment 4. Any other (legacy) downmix metadata will
+                be ignored.                                            */
+  DMX_PRFL_MATRIX_MIX =
+      0x1, /*!< This profile behaves just as the standard profile if
+                advanced downmix metadata (from a DSE) is available. If
+                not, the matrix_mixdown information embedded in the
+                program configuration element (PCE) will be applied. If
+                neither is the case the module creates a mixdown using
+                the default coefficients defined in MPEG-4 Ammendment 4.
+                The profile can be used e.g. to support legacy digital
+                TV (e.g. DVB) streams.                                 */
+  DMX_PRFL_FORCE_MATRIX_MIX =
+      0x2, /*!< Similar to the ::DMX_PRFL_MATRIX_MIX profile but if both
+                the advanced (DSE) and the legacy (PCE) MPEG downmix
+                metadata are available the latter will be applied.     */
+  DMX_PRFL_ARIB_JAPAN =
+      0x3 /*!< Downmix creation as described in ABNT NBR 15602-2. But
+               if advanced downmix metadata is available it will be
+               prefered.                                              */
+} DMX_PROFILE_TYPE;
+
+/**
+ *  \enum PSEUDO_SURROUND_MODE
+ *
+ *  Valid value list for parameter ::DMX_PSEUDO_SURROUND_MODE.
+ */
+typedef enum {
+  NEVER_DO_PS_DMX =
+      -1, /*!< Ignore any metadata and do never create a pseudo surround
+               compatible downmix. (Default)                             */
+  AUTO_PS_DMX = 0, /*!< Create a pseudo surround compatible downmix only if
+                        signalled in bitstreams meta data. */
+  FORCE_PS_DMX =
+      1 /*!< Always create a pseudo surround compatible downmix.
+             CAUTION: This can lead to excessive signal cancellations
+             and signal level differences for non-compatible signals.  */
+} PSEUDO_SURROUND_MODE;
+
+/**
+ *  \enum DUAL_CHANNEL_MODE
+ *
+ *  Valid value list for parameter ::DMX_DUAL_CHANNEL_MODE.
+ */
+typedef enum {
+  STEREO_MODE = 0x0, /*!< Leave stereo signals as they are. */
+  CH1_MODE = 0x1,    /*!< Create a dual mono output signal from channel 1.    */
+  CH2_MODE = 0x2,    /*!< Create a dual mono output signal from channel 2.    */
+  MIXED_MODE = 0x3   /*!< Create a dual mono output signal by mixing the two
+                          channels.   */
+} DUAL_CHANNEL_MODE;
+
+#define DMX_PCM FIXP_DBL
+#define DMX_PCMF FIXP_DBL
+#define DMX_PCM_BITS DFRACT_BITS
+#define FX_DMX2FX_PCM(x) FX_DBL2FX_PCM((FIXP_DBL)(x))
+
+/* ------------------------ *
+ *     MODULES INTERFACE:   *
+ * ------------------------ */
+typedef struct PCM_DMX_INSTANCE *HANDLE_PCM_DOWNMIX;
+
+/*! \addtogroup pcmDmxResetFlags Modules reset flags
+ *  Macros that can be used as parameter for function pcmDmx_Reset() to specify
+ * which parts of the module shall be reset.
+ *  @{
+ *
+ *  \def  PCMDMX_RESET_PARAMS
+ *  Only reset the user specific parameters that have been modified with
+ * pcmDmx_SetParam().
+ *
+ *  \def  PCMDMX_RESET_BS_DATA
+ *  Delete the meta data that has been fed with the appropriate interface
+ * functions.
+ *
+ *  \def  PCMDMX_RESET_FULL
+ *  Reset the complete module instance to the state after pcmDmx_Open() had been
+ * called.
+ */
+#define PCMDMX_RESET_PARAMS (1)
+#define PCMDMX_RESET_BS_DATA (2)
+#define PCMDMX_RESET_FULL (PCMDMX_RESET_PARAMS | PCMDMX_RESET_BS_DATA)
+/*! @} */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Open and initialize an instance of the PCM downmix module
+ * @param[out] pSelf  Pointer to a buffer receiving the handle of the new
+ *instance.
+ * @returns           Returns an error code of type ::PCMDMX_ERROR.
+ **/
+PCMDMX_ERROR pcmDmx_Open(HANDLE_PCM_DOWNMIX *pSelf);
+
+/** Set one parameter for a single instance of the PCM downmix module.
+ * @param[in] self   Handle of PCM downmix instance.
+ * @param[in] param  Parameter to be set. Can be one from the ::PCMDMX_PARAM
+ *list.
+ * @param[in] value  Parameter value.
+ * @returns          Returns an error code of type ::PCMDMX_ERROR.
+ **/
+PCMDMX_ERROR pcmDmx_SetParam(HANDLE_PCM_DOWNMIX self, const PCMDMX_PARAM param,
+                             const INT value);
+
+/** Get one parameter value of a single PCM downmix module instance.
+ * @param[in]  self    Handle of PCM downmix module instance.
+ * @param[in]  param   Parameter to query. Can be one from the ::PCMDMX_PARAM
+ *list.
+ * @param[out] pValue  Pointer to buffer receiving the parameter value.
+ * @returns            Returns an error code of type ::PCMDMX_ERROR.
+ **/
+PCMDMX_ERROR pcmDmx_GetParam(HANDLE_PCM_DOWNMIX self, const PCMDMX_PARAM param,
+                             INT *const pValue);
+
+/** \cond
+ *  Extract relevant downmix meta-data directly from a given bitstream. The
+ *function can handle both data specified in ETSI TS 101 154 or ISO/IEC
+ *14496-3:2009/Amd.4:2013.
+ * @param[in] self         Handle of PCM downmix instance.
+ * @param[in] hBitStream   Handle of FDK bitstream buffer.
+ * @param[in] ancDataBits  Length of ancillary data in bits.
+ * @param[in] isMpeg2      Flag indicating wheter the ancillary data is from a
+ *MPEG-1/2 or a MPEG-4 stream.
+ * @returns                Returns an error code of type ::PCMDMX_ERROR.
+ **/
+PCMDMX_ERROR pcmDmx_Parse(HANDLE_PCM_DOWNMIX self,
+                          HANDLE_FDK_BITSTREAM hBitStream, UINT ancDataBits,
+                          int isMpeg2);
+/** \endcond */
+
+/** Read from a given ancillary data buffer and extract the relevant downmix
+ *meta-data. The function can handle both data specified in ETSI TS 101 154 or
+ *ISO/IEC 14496-3:2009/Amd.4:2013.
+ * @param[in] self          Handle of PCM downmix instance.
+ * @param[in] pAncDataBuf   Pointer to ancillary buffer holding the data.
+ * @param[in] ancDataBytes  Size of ancillary data in bytes.
+ * @param[in] isMpeg2       Flag indicating wheter the ancillary data is from a
+ *MPEG-1/2 or a MPEG-4 stream.
+ * @returns                 Returns an error code of type ::PCMDMX_ERROR.
+ **/
+PCMDMX_ERROR pcmDmx_ReadDvbAncData(HANDLE_PCM_DOWNMIX self, UCHAR *pAncDataBuf,
+                                   UINT ancDataBytes, int isMpeg2);
+
+/** Set the matrix mixdown information extracted from the PCE of an AAC
+ *bitstream.
+ * @param[in] self                  Handle of PCM downmix instance.
+ * @param[in] matrixMixdownPresent  Matrix mixdown index present flag extracted
+ *from PCE.
+ * @param[in] matrixMixdownIdx      The 2 bit matrix mixdown index extracted
+ *from PCE.
+ * @param[in] pseudoSurroundEnable  The pseudo surround enable flag extracted
+ *from PCE.
+ * @returns                         Returns an error code of type
+ *::PCMDMX_ERROR.
+ **/
+PCMDMX_ERROR pcmDmx_SetMatrixMixdownFromPce(HANDLE_PCM_DOWNMIX self,
+                                            int matrixMixdownPresent,
+                                            int matrixMixdownIdx,
+                                            int pseudoSurroundEnable);
+
+/** Reset the module.
+ * @param[in] self   Handle of PCM downmix instance.
+ * @param[in] flags  Flags telling which parts of the module shall be reset.
+ *                   See \ref pcmDmxResetFlags for details.
+ * @returns          Returns an error code of type ::PCMDMX_ERROR.
+ **/
+PCMDMX_ERROR pcmDmx_Reset(HANDLE_PCM_DOWNMIX self, UINT flags);
+
+/** Create a mixdown, bypass or extend the output signal depending on the
+ *modules settings and the respective given input configuration.
+ *
+ * \param[in]     self            Handle of PCM downmix module instance.
+ * \param[in,out] pPcmBuf         Pointer to time buffer with PCM samples.
+ * \param[in]     pcmBufSize      Size of pPcmBuf buffer.
+ * \param[in]     frameSize       The I/O block size which is the number of samples per channel.
+ * \param[in,out] nChannels       Pointer to buffer that holds the number of input channels and
+ *                                where the amount of output channels is written
+ *to.
+ * \param[in]     fInterleaved    Input and output samples are processed interleaved.
+ * \param[in,out] channelType     Array were the corresponding channel type for each output audio
+ *                                channel is stored into.
+ * \param[in,out] channelIndices  Array were the corresponding channel type index for each output
+ *                                audio channel is stored into.
+ * \param[in]     mapDescr        Pointer to a FDK channel mapping descriptor that contains the
+ *                                channel mapping to be used.
+ * \param[out]    pDmxOutScale    Pointer on a field receiving the scale factor that has to be
+ *                                applied on all samples afterwards. If the
+ *handed pointer is NULL the final scaling is done internally.
+ * @returns                       Returns an error code of type ::PCMDMX_ERROR.
+ **/
+PCMDMX_ERROR pcmDmx_ApplyFrame(HANDLE_PCM_DOWNMIX self, DMX_PCM *pPcmBuf,
+                               const int pcmBufSize, UINT frameSize,
+                               INT *nChannels, INT fInterleaved,
+                               AUDIO_CHANNEL_TYPE channelType[],
+                               UCHAR channelIndices[],
+                               const FDK_channelMapDescr *const mapDescr,
+                               INT *pDmxOutScale);
+
+/** Close an instance of the PCM downmix module.
+ * @param[in,out] pSelf  Pointer to a buffer containing the handle of the
+ *instance.
+ * @returns              Returns an error code of type ::PCMDMX_ERROR.
+ **/
+PCMDMX_ERROR pcmDmx_Close(HANDLE_PCM_DOWNMIX *pSelf);
+
+/** Get library info for this module.
+ * @param[out] info  Pointer to an allocated LIB_INFO structure.
+ * @returns          Returns an error code of type ::PCMDMX_ERROR.
+ */
+PCMDMX_ERROR pcmDmx_GetLibInfo(LIB_INFO *info);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PCMDMX_LIB_H */
diff --git a/fdk-aac/libPCMutils/src/limiter.cpp b/fdk-aac/libPCMutils/src/limiter.cpp
new file mode 100644
index 0000000..a799a51
--- /dev/null
+++ b/fdk-aac/libPCMutils/src/limiter.cpp
@@ -0,0 +1,570 @@
+/* -----------------------------------------------------------------------------
+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
+----------------------------------------------------------------------------- */
+
+/**************************** PCM utility library ******************************
+
+   Author(s):   Matthias Neusinger
+
+   Description: Hard limiter for clipping prevention
+
+*******************************************************************************/
+
+#include "limiter.h"
+#include "FDK_core.h"
+
+/* library version */
+#include "version.h"
+/* library title */
+#define TDLIMIT_LIB_TITLE "TD Limiter Lib"
+
+/* create limiter */
+TDLimiterPtr pcmLimiter_Create(unsigned int maxAttackMs, unsigned int releaseMs,
+                               FIXP_DBL threshold, unsigned int maxChannels,
+                               UINT maxSampleRate) {
+  TDLimiterPtr limiter = NULL;
+  unsigned int attack, release;
+  FIXP_DBL attackConst, releaseConst, exponent;
+  INT e_ans;
+
+  /* calc attack and release time in samples */
+  attack = (unsigned int)(maxAttackMs * maxSampleRate / 1000);
+  release = (unsigned int)(releaseMs * maxSampleRate / 1000);
+
+  /* alloc limiter struct */
+  limiter = (TDLimiterPtr)FDKcalloc(1, sizeof(struct TDLimiter));
+  if (!limiter) return NULL;
+
+  /* alloc max and delay buffers */
+  limiter->maxBuf = (FIXP_DBL*)FDKcalloc(attack + 1, sizeof(FIXP_DBL));
+  limiter->delayBuf =
+      (FIXP_DBL*)FDKcalloc(attack * maxChannels, sizeof(FIXP_DBL));
+
+  if (!limiter->maxBuf || !limiter->delayBuf) {
+    pcmLimiter_Destroy(limiter);
+    return NULL;
+  }
+
+  /* attackConst = pow(0.1, 1.0 / (attack + 1)) */
+  exponent = invFixp(attack + 1);
+  attackConst = fPow(FL2FXCONST_DBL(0.1f), 0, exponent, 0, &e_ans);
+  attackConst = scaleValue(attackConst, e_ans);
+
+  /* releaseConst  = (float)pow(0.1, 1.0 / (release + 1)) */
+  exponent = invFixp(release + 1);
+  releaseConst = fPow(FL2FXCONST_DBL(0.1f), 0, exponent, 0, &e_ans);
+  releaseConst = scaleValue(releaseConst, e_ans);
+
+  /* init parameters */
+  limiter->attackMs = maxAttackMs;
+  limiter->maxAttackMs = maxAttackMs;
+  limiter->releaseMs = releaseMs;
+  limiter->attack = attack;
+  limiter->attackConst = attackConst;
+  limiter->releaseConst = releaseConst;
+  limiter->threshold = threshold >> TDL_GAIN_SCALING;
+  limiter->channels = maxChannels;
+  limiter->maxChannels = maxChannels;
+  limiter->sampleRate = maxSampleRate;
+  limiter->maxSampleRate = maxSampleRate;
+
+  pcmLimiter_Reset(limiter);
+
+  return limiter;
+}
+
+/* apply limiter */
+TDLIMITER_ERROR pcmLimiter_Apply(TDLimiterPtr limiter, PCM_LIM* samplesIn,
+                                 INT_PCM* samplesOut, FIXP_DBL* RESTRICT pGain,
+                                 const INT* RESTRICT gain_scale,
+                                 const UINT gain_size, const UINT gain_delay,
+                                 const UINT nSamples) {
+  unsigned int i, j;
+  FIXP_DBL tmp1;
+  FIXP_DBL tmp2;
+  FIXP_DBL tmp, old, gain, additionalGain = 0, additionalGainUnfiltered;
+  FIXP_DBL minGain = FL2FXCONST_DBL(1.0f / (1 << 1));
+
+  FDK_ASSERT(gain_size == 1);
+  FDK_ASSERT(gain_delay <= nSamples);
+
+  if (limiter == NULL) return TDLIMIT_INVALID_HANDLE;
+
+  {
+    unsigned int channels = limiter->channels;
+    unsigned int attack = limiter->attack;
+    FIXP_DBL attackConst = limiter->attackConst;
+    FIXP_DBL releaseConst = limiter->releaseConst;
+    FIXP_DBL threshold = limiter->threshold;
+
+    FIXP_DBL max = limiter->max;
+    FIXP_DBL* maxBuf = limiter->maxBuf;
+    unsigned int maxBufIdx = limiter->maxBufIdx;
+    FIXP_DBL cor = limiter->cor;
+    FIXP_DBL* delayBuf = limiter->delayBuf;
+    unsigned int delayBufIdx = limiter->delayBufIdx;
+
+    FIXP_DBL smoothState0 = limiter->smoothState0;
+    FIXP_DBL additionalGainSmoothState = limiter->additionalGainFilterState;
+    FIXP_DBL additionalGainSmoothState1 = limiter->additionalGainFilterState1;
+
+    if (!gain_delay) {
+      additionalGain = pGain[0];
+      if (gain_scale[0] > 0) {
+        additionalGain <<= gain_scale[0];
+      } else {
+        additionalGain >>= -gain_scale[0];
+      }
+    }
+
+    for (i = 0; i < nSamples; i++) {
+      if (gain_delay) {
+        if (i < gain_delay) {
+          additionalGainUnfiltered = limiter->additionalGainPrev;
+        } else {
+          additionalGainUnfiltered = pGain[0];
+        }
+
+        /* Smooth additionalGain */
+        /* [b,a] = butter(1, 0.01) */
+        static const FIXP_SGL b[] = {FL2FXCONST_SGL(0.015466 * 2.0),
+                                     FL2FXCONST_SGL(0.015466 * 2.0)};
+        static const FIXP_SGL a[] = {(FIXP_SGL)MAXVAL_SGL,
+                                     FL2FXCONST_SGL(-0.96907)};
+        additionalGain = -fMult(additionalGainSmoothState, a[1]) +
+                         fMultDiv2(additionalGainUnfiltered, b[0]) +
+                         fMultDiv2(additionalGainSmoothState1, b[1]);
+        additionalGainSmoothState1 = additionalGainUnfiltered;
+        additionalGainSmoothState = additionalGain;
+
+        /* Apply the additional scaling that has no delay and no smoothing */
+        if (gain_scale[0] > 0) {
+          additionalGain <<= gain_scale[0];
+        } else {
+          additionalGain >>= -gain_scale[0];
+        }
+      }
+      /* get maximum absolute sample value of all channels, including the
+       * additional gain. */
+      tmp1 = (FIXP_DBL)0;
+      for (j = 0; j < channels; j++) {
+        tmp2 = PCM_LIM2FIXP_DBL(samplesIn[j]);
+        tmp2 = fAbs(tmp2);
+        tmp2 = FIXP_DBL(INT(tmp2) ^ INT((tmp2 >> (SAMPLE_BITS_LIM - 1))));
+        tmp1 = fMax(tmp1, tmp2);
+      }
+      tmp = fMult(tmp1, additionalGain);
+
+      /* set threshold as lower border to save calculations in running maximum
+       * algorithm */
+      tmp = fMax(tmp, threshold);
+
+      /* running maximum */
+      old = maxBuf[maxBufIdx];
+      maxBuf[maxBufIdx] = tmp;
+
+      if (tmp >= max) {
+        /* new sample is greater than old maximum, so it is the new maximum */
+        max = tmp;
+      } else if (old < max) {
+        /* maximum does not change, as the sample, which has left the window was
+           not the maximum */
+      } else {
+        /* the old maximum has left the window, we have to search the complete
+           buffer for the new max */
+        max = maxBuf[0];
+        for (j = 1; j <= attack; j++) {
+          max = fMax(max, maxBuf[j]);
+        }
+      }
+      maxBufIdx++;
+      if (maxBufIdx >= attack + 1) maxBufIdx = 0;
+
+      /* calc gain */
+      /* gain is downscaled by one, so that gain = 1.0 can be represented */
+      if (max > threshold) {
+        gain = fDivNorm(threshold, max) >> 1;
+      } else {
+        gain = FL2FXCONST_DBL(1.0f / (1 << 1));
+      }
+
+      /* gain smoothing, method: TDL_EXPONENTIAL */
+      /* first order IIR filter with attack correction to avoid overshoots */
+
+      /* correct the 'aiming' value of the exponential attack to avoid the
+       * remaining overshoot */
+      if (gain < smoothState0) {
+        cor = fMin(cor,
+                   fMultDiv2((gain - fMultDiv2(FL2FXCONST_SGL(0.1f * (1 << 1)),
+                                               smoothState0)),
+                             FL2FXCONST_SGL(1.11111111f / (1 << 1)))
+                       << 2);
+      } else {
+        cor = gain;
+      }
+
+      /* smoothing filter */
+      if (cor < smoothState0) {
+        smoothState0 =
+            fMult(attackConst, (smoothState0 - cor)) + cor; /* attack */
+        smoothState0 = fMax(smoothState0, gain); /* avoid overshooting target */
+      } else {
+        /* sign inversion twice to round towards +infinity,
+           so that gain can converge to 1.0 again,
+           for bit-identical output when limiter is not active */
+        smoothState0 =
+            -fMult(releaseConst, -(smoothState0 - cor)) + cor; /* release */
+      }
+
+      gain = smoothState0;
+
+      FIXP_DBL* p_delayBuf = &delayBuf[delayBufIdx * channels + 0];
+      if (gain < FL2FXCONST_DBL(1.0f / (1 << 1))) {
+        gain <<= 1;
+        /* lookahead delay, apply gain */
+        for (j = 0; j < channels; j++) {
+          tmp = p_delayBuf[j];
+          p_delayBuf[j] = fMult((FIXP_PCM_LIM)samplesIn[j], additionalGain);
+
+          /* Apply gain to delayed signal */
+          tmp = fMultDiv2(tmp, gain);
+
+          samplesOut[j] = (INT_PCM)FX_DBL2FX_PCM((FIXP_DBL)SATURATE_LEFT_SHIFT(
+              tmp, TDL_GAIN_SCALING + 1, DFRACT_BITS));
+        }
+        gain >>= 1;
+      } else {
+        /* lookahead delay, apply gain=1.0f */
+        for (j = 0; j < channels; j++) {
+          tmp = p_delayBuf[j];
+          p_delayBuf[j] = fMult((FIXP_PCM_LIM)samplesIn[j], additionalGain);
+          samplesOut[j] = (INT_PCM)FX_DBL2FX_PCM((FIXP_DBL)SATURATE_LEFT_SHIFT(
+              tmp, TDL_GAIN_SCALING, DFRACT_BITS));
+        }
+      }
+
+      delayBufIdx++;
+      if (delayBufIdx >= attack) {
+        delayBufIdx = 0;
+      }
+
+      /* save minimum gain factor */
+      if (gain < minGain) {
+        minGain = gain;
+      }
+
+      /* advance sample pointer by <channel> samples */
+      samplesIn += channels;
+      samplesOut += channels;
+    }
+
+    limiter->max = max;
+    limiter->maxBufIdx = maxBufIdx;
+    limiter->cor = cor;
+    limiter->delayBufIdx = delayBufIdx;
+
+    limiter->smoothState0 = smoothState0;
+    limiter->additionalGainFilterState = additionalGainSmoothState;
+    limiter->additionalGainFilterState1 = additionalGainSmoothState1;
+
+    limiter->minGain = minGain;
+
+    limiter->additionalGainPrev = pGain[0];
+
+    return TDLIMIT_OK;
+  }
+}
+
+/* set limiter threshold */
+TDLIMITER_ERROR pcmLimiter_SetThreshold(TDLimiterPtr limiter,
+                                        FIXP_DBL threshold) {
+  if (limiter == NULL) return TDLIMIT_INVALID_HANDLE;
+
+  limiter->threshold = threshold >> TDL_GAIN_SCALING;
+
+  return TDLIMIT_OK;
+}
+
+/* reset limiter */
+TDLIMITER_ERROR pcmLimiter_Reset(TDLimiterPtr limiter) {
+  if (limiter != NULL) {
+    limiter->maxBufIdx = 0;
+    limiter->delayBufIdx = 0;
+    limiter->max = (FIXP_DBL)0;
+    limiter->cor = FL2FXCONST_DBL(1.0f / (1 << 1));
+    limiter->smoothState0 = FL2FXCONST_DBL(1.0f / (1 << 1));
+    limiter->minGain = FL2FXCONST_DBL(1.0f / (1 << 1));
+
+    limiter->additionalGainPrev =
+        FL2FXCONST_DBL(1.0f / (1 << TDL_GAIN_SCALING));
+    limiter->additionalGainFilterState =
+        FL2FXCONST_DBL(1.0f / (1 << TDL_GAIN_SCALING));
+    limiter->additionalGainFilterState1 =
+        FL2FXCONST_DBL(1.0f / (1 << TDL_GAIN_SCALING));
+
+    FDKmemset(limiter->maxBuf, 0, (limiter->attack + 1) * sizeof(FIXP_DBL));
+    FDKmemset(limiter->delayBuf, 0,
+              limiter->attack * limiter->channels * sizeof(FIXP_DBL));
+  } else {
+    return TDLIMIT_INVALID_HANDLE;
+  }
+
+  return TDLIMIT_OK;
+}
+
+/* destroy limiter */
+TDLIMITER_ERROR pcmLimiter_Destroy(TDLimiterPtr limiter) {
+  if (limiter != NULL) {
+    FDKfree(limiter->maxBuf);
+    FDKfree(limiter->delayBuf);
+
+    FDKfree(limiter);
+  } else {
+    return TDLIMIT_INVALID_HANDLE;
+  }
+  return TDLIMIT_OK;
+}
+
+/* get delay in samples */
+unsigned int pcmLimiter_GetDelay(TDLimiterPtr limiter) {
+  FDK_ASSERT(limiter != NULL);
+  return limiter->attack;
+}
+
+/* get maximum gain reduction of last processed block */
+INT pcmLimiter_GetMaxGainReduction(TDLimiterPtr limiter) {
+  /* maximum gain reduction in dB = -20 * log10(limiter->minGain)
+     = -20 * log2(limiter->minGain)/log2(10) = -6.0206*log2(limiter->minGain) */
+  int e_ans;
+  FIXP_DBL loggain, maxGainReduction;
+
+  FDK_ASSERT(limiter != NULL);
+
+  loggain = fLog2(limiter->minGain, 1, &e_ans);
+
+  maxGainReduction = fMult(loggain, FL2FXCONST_DBL(-6.0206f / (1 << 3)));
+
+  return fixp_roundToInt(maxGainReduction, (e_ans + 3));
+}
+
+/* set number of channels */
+TDLIMITER_ERROR pcmLimiter_SetNChannels(TDLimiterPtr limiter,
+                                        unsigned int nChannels) {
+  if (limiter == NULL) return TDLIMIT_INVALID_HANDLE;
+
+  if (nChannels > limiter->maxChannels) return TDLIMIT_INVALID_PARAMETER;
+
+  limiter->channels = nChannels;
+  // pcmLimiter_Reset(limiter);
+
+  return TDLIMIT_OK;
+}
+
+/* set sampling rate */
+TDLIMITER_ERROR pcmLimiter_SetSampleRate(TDLimiterPtr limiter,
+                                         UINT sampleRate) {
+  unsigned int attack, release;
+  FIXP_DBL attackConst, releaseConst, exponent;
+  INT e_ans;
+
+  if (limiter == NULL) return TDLIMIT_INVALID_HANDLE;
+
+  if (sampleRate > limiter->maxSampleRate) return TDLIMIT_INVALID_PARAMETER;
+
+  /* update attack and release time in samples */
+  attack = (unsigned int)(limiter->attackMs * sampleRate / 1000);
+  release = (unsigned int)(limiter->releaseMs * sampleRate / 1000);
+
+  /* attackConst = pow(0.1, 1.0 / (attack + 1)) */
+  exponent = invFixp(attack + 1);
+  attackConst = fPow(FL2FXCONST_DBL(0.1f), 0, exponent, 0, &e_ans);
+  attackConst = scaleValue(attackConst, e_ans);
+
+  /* releaseConst  = (float)pow(0.1, 1.0 / (release + 1)) */
+  exponent = invFixp(release + 1);
+  releaseConst = fPow(FL2FXCONST_DBL(0.1f), 0, exponent, 0, &e_ans);
+  releaseConst = scaleValue(releaseConst, e_ans);
+
+  limiter->attack = attack;
+  limiter->attackConst = attackConst;
+  limiter->releaseConst = releaseConst;
+  limiter->sampleRate = sampleRate;
+
+  /* reset */
+  // pcmLimiter_Reset(limiter);
+
+  return TDLIMIT_OK;
+}
+
+/* set attack time */
+TDLIMITER_ERROR pcmLimiter_SetAttack(TDLimiterPtr limiter,
+                                     unsigned int attackMs) {
+  unsigned int attack;
+  FIXP_DBL attackConst, exponent;
+  INT e_ans;
+
+  if (limiter == NULL) return TDLIMIT_INVALID_HANDLE;
+
+  if (attackMs > limiter->maxAttackMs) return TDLIMIT_INVALID_PARAMETER;
+
+  /* calculate attack time in samples */
+  attack = (unsigned int)(attackMs * limiter->sampleRate / 1000);
+
+  /* attackConst = pow(0.1, 1.0 / (attack + 1)) */
+  exponent = invFixp(attack + 1);
+  attackConst = fPow(FL2FXCONST_DBL(0.1f), 0, exponent, 0, &e_ans);
+  attackConst = scaleValue(attackConst, e_ans);
+
+  limiter->attack = attack;
+  limiter->attackConst = attackConst;
+  limiter->attackMs = attackMs;
+
+  return TDLIMIT_OK;
+}
+
+/* set release time */
+TDLIMITER_ERROR pcmLimiter_SetRelease(TDLimiterPtr limiter,
+                                      unsigned int releaseMs) {
+  unsigned int release;
+  FIXP_DBL releaseConst, exponent;
+  INT e_ans;
+
+  if (limiter == NULL) return TDLIMIT_INVALID_HANDLE;
+
+  /* calculate  release time in samples */
+  release = (unsigned int)(releaseMs * limiter->sampleRate / 1000);
+
+  /* releaseConst  = (float)pow(0.1, 1.0 / (release + 1)) */
+  exponent = invFixp(release + 1);
+  releaseConst = fPow(FL2FXCONST_DBL(0.1f), 0, exponent, 0, &e_ans);
+  releaseConst = scaleValue(releaseConst, e_ans);
+
+  limiter->releaseConst = releaseConst;
+  limiter->releaseMs = releaseMs;
+
+  return TDLIMIT_OK;
+}
+
+/* Get library info for this module. */
+TDLIMITER_ERROR pcmLimiter_GetLibInfo(LIB_INFO* info) {
+  int i;
+
+  if (info == NULL) {
+    return TDLIMIT_INVALID_PARAMETER;
+  }
+
+  /* Search for next free tab */
+  for (i = 0; i < FDK_MODULE_LAST; i++) {
+    if (info[i].module_id == FDK_NONE) break;
+  }
+  if (i == FDK_MODULE_LAST) {
+    return TDLIMIT_UNKNOWN;
+  }
+
+  /* Add the library info */
+  info[i].module_id = FDK_TDLIMIT;
+  info[i].version =
+      LIB_VERSION(PCMUTIL_LIB_VL0, PCMUTIL_LIB_VL1, PCMUTIL_LIB_VL2);
+  LIB_VERSION_STRING(info + i);
+  info[i].build_date = PCMUTIL_LIB_BUILD_DATE;
+  info[i].build_time = PCMUTIL_LIB_BUILD_TIME;
+  info[i].title = TDLIMIT_LIB_TITLE;
+
+  /* Set flags */
+  info[i].flags = CAPF_LIMITER;
+
+  /* Add lib info for FDK tools (if not yet done). */
+  FDK_toolsGetLibInfo(info);
+
+  return TDLIMIT_OK;
+}
diff --git a/fdk-aac/libPCMutils/src/pcm_utils.cpp b/fdk-aac/libPCMutils/src/pcm_utils.cpp
new file mode 100644
index 0000000..5dd18d9
--- /dev/null
+++ b/fdk-aac/libPCMutils/src/pcm_utils.cpp
@@ -0,0 +1,195 @@
+/* -----------------------------------------------------------------------------
+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
+----------------------------------------------------------------------------- */
+
+/**************************** PCM utility library ******************************
+
+   Author(s):   Arthur Tritthart, Alfonso Pino Garcia
+
+   Description: Functions that perform (de)interleaving combined with format
+change
+
+*******************************************************************************/
+
+#include "pcm_utils.h"
+
+/* library version */
+#include "version.h"
+
+void FDK_interleave(const FIXP_DBL *RESTRICT pIn, LONG *RESTRICT pOut,
+                    const UINT channels, const UINT frameSize,
+                    const UINT length) {
+  for (UINT sample = 0; sample < length; sample++) {
+    const FIXP_DBL *In = &pIn[sample];
+    for (UINT ch = 0; ch < channels; ch++) {
+      *pOut++ = (LONG)In[0];
+      In += frameSize;
+    }
+  }
+}
+
+void FDK_interleave(const FIXP_DBL *RESTRICT pIn, SHORT *RESTRICT pOut,
+                    const UINT channels, const UINT frameSize,
+                    const UINT length) {
+  for (UINT sample = 0; sample < length; sample++) {
+    const FIXP_DBL *In = &pIn[sample];
+    for (UINT ch = 0; ch < channels; ch++) {
+      *pOut++ = (SHORT)FX_DBL2FX_SGL(In[0]);
+      In += frameSize;
+    }
+  }
+}
+
+void FDK_interleave(const FIXP_SGL *RESTRICT pIn, SHORT *RESTRICT pOut,
+                    const UINT channels, const UINT frameSize,
+                    const UINT length) {
+  for (UINT sample = 0; sample < length; sample++) {
+    const FIXP_SGL *In = &pIn[sample];
+    for (UINT ch = 0; ch < channels; ch++) {
+      *pOut++ = (SHORT)In[0];
+      In += frameSize;
+    }
+  }
+}
+
+void FDK_deinterleave(const LONG *RESTRICT pIn, SHORT *RESTRICT _pOut,
+                      const UINT channels, const UINT frameSize,
+                      const UINT length) {
+  for (UINT ch = 0; ch < channels; ch++) {
+    SHORT *pOut = _pOut + length * ch;
+    const LONG *In = &pIn[ch];
+    for (UINT sample = 0; sample < frameSize; sample++) {
+      *pOut++ = (SHORT)(In[0] >> 16);
+      In += channels;
+    }
+  }
+}
+
+void FDK_deinterleave(const LONG *RESTRICT pIn, LONG *RESTRICT _pOut,
+                      const UINT channels, const UINT frameSize,
+                      const UINT length) {
+  for (UINT ch = 0; ch < channels; ch++) {
+    LONG *pOut = _pOut + length * ch;
+    const LONG *In = &pIn[ch];
+    for (UINT sample = 0; sample < frameSize; sample++) {
+      *pOut++ = In[0];
+      In += channels;
+    }
+  }
+}
+
+void FDK_deinterleave(const SHORT *RESTRICT pIn, SHORT *RESTRICT _pOut,
+                      const UINT channels, const UINT frameSize,
+                      const UINT length) {
+  for (UINT ch = 0; ch < channels; ch++) {
+    SHORT *pOut = _pOut + length * ch;
+    const SHORT *In = &pIn[ch];
+    for (UINT sample = 0; sample < frameSize; sample++) {
+      *pOut++ = In[0];
+      In += channels;
+    }
+  }
+}
+
+void FDK_deinterleave(const SHORT *RESTRICT pIn, LONG *RESTRICT _pOut,
+                      const UINT channels, const UINT frameSize,
+                      const UINT length) {
+  for (UINT ch = 0; ch < channels; ch++) {
+    LONG *pOut = _pOut + length * ch;
+    const SHORT *In = &pIn[ch];
+    for (UINT sample = 0; sample < frameSize; sample++) {
+      *pOut++ = (LONG)In[0] << 16;
+      In += channels;
+    }
+  }
+}
diff --git a/fdk-aac/libPCMutils/src/pcmdmx_lib.cpp b/fdk-aac/libPCMutils/src/pcmdmx_lib.cpp
new file mode 100644
index 0000000..2070dbc
--- /dev/null
+++ b/fdk-aac/libPCMutils/src/pcmdmx_lib.cpp
@@ -0,0 +1,2662 @@
+/* -----------------------------------------------------------------------------
+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
+----------------------------------------------------------------------------- */
+
+/**************************** PCM utility library ******************************
+
+   Author(s):   Christian Griebel
+
+   Description: Defines functions that perform downmixing or a simple channel
+                expansion in the PCM time domain.
+
+*******************************************************************************/
+
+#include "pcmdmx_lib.h"
+
+#include "genericStds.h"
+#include "fixpoint_math.h"
+#include "FDK_core.h"
+
+/* library version */
+#include "version.h"
+/* library title */
+#define PCMDMX_LIB_TITLE "PCM Downmix Lib"
+
+#define FALSE 0
+#define TRUE 1
+#define IN 0
+#define OUT 1
+
+/* Type definitions: */
+#define FIXP_DMX FIXP_SGL
+#define FX_DMX2FX_DBL(x) FX_SGL2FX_DBL((FIXP_SGL)(x))
+#define FX_DBL2FX_DMX(x) FX_DBL2FX_SGL(x)
+#define FL2FXCONST_DMX(x) FL2FXCONST_SGL(x)
+#define MAXVAL_DMX MAXVAL_SGL
+#define FX_DMX2SHRT(x) ((SHORT)(x))
+#define FX_DMX2FL(x) FX_DBL2FL(FX_DMX2FX_DBL(x))
+
+/* Fixed and unique channel group indices.
+ * The last group index has to be smaller than ( 4 ). */
+#define CH_GROUP_FRONT (0)
+#define CH_GROUP_SIDE (1)
+#define CH_GROUP_REAR (2)
+#define CH_GROUP_LFE (3)
+
+/* Fixed and unique channel plain indices. */
+#define CH_PLAIN_NORMAL (0)
+#define CH_PLAIN_TOP (1)
+#define CH_PLAIN_BOTTOM (2)
+
+/* The ordering of the following fixed channel labels has to be in MPEG-4 style.
+ * From the center to the back with left and right channel interleaved (starting
+ * with left). The last channel label index has to be smaller than ( 8 ). */
+#define CENTER_FRONT_CHANNEL (0) /* C  */
+#define LEFT_FRONT_CHANNEL (1)   /* L  */
+#define RIGHT_FRONT_CHANNEL (2)  /* R  */
+#define LEFT_REAR_CHANNEL \
+  (3) /* Lr (aka left back channel) or center back channel */
+#define RIGHT_REAR_CHANNEL (4)      /* Rr (aka right back channel) */
+#define LOW_FREQUENCY_CHANNEL (5)   /* Lf */
+#define LEFT_MULTIPRPS_CHANNEL (6)  /* Left multipurpose channel */
+#define RIGHT_MULTIPRPS_CHANNEL (7) /* Right multipurpose channel */
+
+/* 22.2 channel specific fixed channel lables: */
+#define LEFT_SIDE_CHANNEL (8)            /* Lss  */
+#define RIGHT_SIDE_CHANNEL (9)           /* Rss  */
+#define CENTER_REAR_CHANNEL (10)         /* Cs   */
+#define CENTER_FRONT_CHANNEL_TOP (11)    /* Cv   */
+#define LEFT_FRONT_CHANNEL_TOP (12)      /* Lv   */
+#define RIGHT_FRONT_CHANNEL_TOP (13)     /* Rv   */
+#define LEFT_SIDE_CHANNEL_TOP (14)       /* Lvss */
+#define RIGHT_SIDE_CHANNEL_TOP (15)      /* Rvss */
+#define CENTER_SIDE_CHANNEL_TOP (16)     /* Ts   */
+#define LEFT_REAR_CHANNEL_TOP (17)       /* Lvr  */
+#define RIGHT_REAR_CHANNEL_TOP (18)      /* Rvr  */
+#define CENTER_REAR_CHANNEL_TOP (19)     /* Cvr  */
+#define CENTER_FRONT_CHANNEL_BOTTOM (20) /* Cb   */
+#define LEFT_FRONT_CHANNEL_BOTTOM (21)   /* Lb   */
+#define RIGHT_FRONT_CHANNEL_BOTTOM (22)  /* Rb   */
+#define LOW_FREQUENCY_CHANNEL_2 (23)     /* LFE2 */
+
+/* More constants */
+#define ONE_CHANNEL (1)
+#define TWO_CHANNEL (2)
+#define SIX_CHANNEL (6)
+#define EIGHT_CHANNEL (8)
+#define TWENTY_FOUR_CHANNEL (24)
+
+#define PCMDMX_THRESHOLD_MAP_HEAT_1 (0) /* Store only exact matches */
+#define PCMDMX_THRESHOLD_MAP_HEAT_2 (20)
+#define PCMDMX_THRESHOLD_MAP_HEAT_3 \
+  (256) /* Do not assign normal channels to LFE */
+
+#define SP_Z_NRM (0)
+#define SP_Z_TOP (2)
+#define SP_Z_BOT (-2)
+#define SP_Z_LFE (-18)
+#define SP_Z_MUL (8) /* Should be smaller than SP_Z_LFE */
+
+typedef struct {
+  SCHAR x; /* horizontal position:  center (0), left (-), right (+) */
+  SCHAR y; /* deepth position:      front, side, back, position */
+  SCHAR z; /* heigth positions:     normal, top, bottom, lfe */
+} PCM_DMX_SPEAKER_POSITION;
+
+/* CAUTION: The maximum x-value should be less or equal to
+ * PCMDMX_SPKR_POS_X_MAX_WIDTH. */
+static const PCM_DMX_SPEAKER_POSITION spkrSlotPos[] = {
+    /*  x,  y,  z  */
+    {0, 0, SP_Z_NRM},  /* 0  CENTER_FRONT_CHANNEL        */
+    {-2, 0, SP_Z_NRM}, /* 1  LEFT_FRONT_CHANNEL          */
+    {2, 0, SP_Z_NRM},  /* 2  RIGHT_FRONT_CHANNEL         */
+    {-3, 4, SP_Z_NRM}, /* 3  LEFT_REAR_CHANNEL           */
+    {3, 4, SP_Z_NRM},  /* 4  RIGHT_REAR_CHANNEL          */
+    {0, 0, SP_Z_LFE},  /* 5  LOW_FREQUENCY_CHANNEL       */
+    {-2, 2, SP_Z_MUL}, /* 6  LEFT_MULTIPRPS_CHANNEL      */
+    {2, 2, SP_Z_MUL}   /* 7  RIGHT_MULTIPRPS_CHANNEL     */
+};
+
+/* List of packed channel modes */
+typedef enum { /* CH_MODE_<numFrontCh>_<numSideCh>_<numBackCh>_<numLfCh> */
+               CH_MODE_UNDEFINED = 0x0000,
+               /* 1 channel */
+               CH_MODE_1_0_0_0 = 0x0001, /* chCfg 1 */
+               /* 2 channels */
+               CH_MODE_2_0_0_0 = 0x0002 /* chCfg 2 */
+                                        /* 3 channels */
+               ,
+               CH_MODE_3_0_0_0 = 0x0003, /* chCfg 3 */
+               CH_MODE_2_0_1_0 = 0x0102,
+               CH_MODE_2_0_0_1 = 0x1002,
+               /* 4 channels */
+               CH_MODE_3_0_1_0 = 0x0103, /* chCfg 4 */
+               CH_MODE_2_0_2_0 = 0x0202,
+               CH_MODE_2_0_1_1 = 0x1102,
+               CH_MODE_4_0_0_0 = 0x0004,
+               /* 5 channels */
+               CH_MODE_3_0_2_0 = 0x0203, /* chCfg 5 */
+               CH_MODE_2_0_2_1 = 0x1202,
+               CH_MODE_3_0_1_1 = 0x1103,
+               CH_MODE_3_2_0_0 = 0x0023,
+               CH_MODE_5_0_0_0 = 0x0005,
+               /* 6 channels */
+               CH_MODE_3_0_2_1 = 0x1203, /* chCfg 6 */
+               CH_MODE_3_2_0_1 = 0x1023,
+               CH_MODE_3_2_1_0 = 0x0123,
+               CH_MODE_5_0_1_0 = 0x0105,
+               CH_MODE_6_0_0_0 = 0x0006,
+               /* 7 channels */
+               CH_MODE_2_2_2_1 = 0x1222,
+               CH_MODE_3_0_3_1 = 0x1303, /* chCfg 11 */
+               CH_MODE_3_2_1_1 = 0x1123,
+               CH_MODE_3_2_2_0 = 0x0223,
+               CH_MODE_3_0_2_2 = 0x2203,
+               CH_MODE_5_0_2_0 = 0x0205,
+               CH_MODE_5_0_1_1 = 0x1105,
+               CH_MODE_7_0_0_0 = 0x0007,
+               /* 8 channels */
+               CH_MODE_3_2_2_1 = 0x1223,
+               CH_MODE_3_0_4_1 = 0x1403, /* chCfg 12 */
+               CH_MODE_5_0_2_1 = 0x1205, /* chCfg 7 + 14 */
+               CH_MODE_5_2_1_0 = 0x0125,
+               CH_MODE_3_2_1_2 = 0x2123,
+               CH_MODE_2_2_2_2 = 0x2222,
+               CH_MODE_3_0_3_2 = 0x2303,
+               CH_MODE_8_0_0_0 = 0x0008
+
+} PCM_DMX_CHANNEL_MODE;
+
+/* These are the channel configurations linked to
+   the number of output channels give by the user: */
+static const PCM_DMX_CHANNEL_MODE outChModeTable[(8) + 1] = {
+    CH_MODE_UNDEFINED,
+    CH_MODE_1_0_0_0, /* 1 channel  */
+    CH_MODE_2_0_0_0  /* 2 channels */
+    ,
+    CH_MODE_3_0_0_0, /* 3 channels */
+    CH_MODE_3_0_1_0, /* 4 channels */
+    CH_MODE_3_0_2_0, /* 5 channels */
+    CH_MODE_3_0_2_1  /* 6 channels */
+    ,
+    CH_MODE_3_0_3_1, /* 7 channels */
+    CH_MODE_3_0_4_1  /* 8 channels */
+};
+
+static const FIXP_DMX abMixLvlValueTab[8] = {
+    FL2FXCONST_DMX(0.500f), /* scaled by 1 */
+    FL2FXCONST_DMX(0.841f), FL2FXCONST_DMX(0.707f), FL2FXCONST_DMX(0.596f),
+    FL2FXCONST_DMX(0.500f), FL2FXCONST_DMX(0.422f), FL2FXCONST_DMX(0.355f),
+    FL2FXCONST_DMX(0.0f)};
+
+static const FIXP_DMX lfeMixLvlValueTab[16] = {
+    /*             value,        scale */
+    FL2FXCONST_DMX(0.7905f), /*     2 */
+    FL2FXCONST_DMX(0.5000f), /*     2 */
+    FL2FXCONST_DMX(0.8395f), /*     1 */
+    FL2FXCONST_DMX(0.7065f), /*     1 */
+    FL2FXCONST_DMX(0.5945f), /*     1 */
+    FL2FXCONST_DMX(0.500f),  /*     1 */
+    FL2FXCONST_DMX(0.841f),  /*     0 */
+    FL2FXCONST_DMX(0.707f),  /*     0 */
+    FL2FXCONST_DMX(0.596f),  /*     0 */
+    FL2FXCONST_DMX(0.500f),  /*     0 */
+    FL2FXCONST_DMX(0.316f),  /*     0 */
+    FL2FXCONST_DMX(0.178f),  /*     0 */
+    FL2FXCONST_DMX(0.100f),  /*     0 */
+    FL2FXCONST_DMX(0.032f),  /*     0 */
+    FL2FXCONST_DMX(0.010f),  /*     0 */
+    FL2FXCONST_DMX(0.000f)   /*     0 */
+};
+
+/* MPEG matrix mixdown:
+    Set 1:  L' = (1 + 2^-0.5 + A )^-1 * [L + C * 2^-0.5 + A * Ls];
+            R' = (1 + 2^-0.5 + A )^-1 * [R + C * 2^-0.5 + A * Rs];
+
+    Set 2:  L' = (1 + 2^-0.5 + 2A )^-1 * [L + C * 2^-0.5 - A * (Ls + Rs)];
+            R' = (1 + 2^-0.5 + 2A )^-1 * [R + C * 2^-0.5 + A * (Ls + Rs)];
+
+    M = (3 + 2A)^-1 * [L + C + R + A*(Ls + Rs)];
+*/
+static const FIXP_DMX mpegMixDownIdx2Coef[4] = {
+    FL2FXCONST_DMX(0.70710678f), FL2FXCONST_DMX(0.5f),
+    FL2FXCONST_DMX(0.35355339f), FL2FXCONST_DMX(0.0f)};
+
+static const FIXP_DMX mpegMixDownIdx2PreFact[3][4] = {
+    {/* Set 1: */
+     FL2FXCONST_DMX(0.4142135623730950f), FL2FXCONST_DMX(0.4530818393219728f),
+     FL2FXCONST_DMX(0.4852813742385703f), FL2FXCONST_DMX(0.5857864376269050f)},
+    {/* Set 2: */
+     FL2FXCONST_DMX(0.3203772410170407f), FL2FXCONST_DMX(0.3693980625181293f),
+     FL2FXCONST_DMX(0.4142135623730950f), FL2FXCONST_DMX(0.5857864376269050f)},
+    {/* Mono DMX set: */
+     FL2FXCONST_DMX(0.2265409196609864f), FL2FXCONST_DMX(0.25f),
+     FL2FXCONST_DMX(0.2697521433898179f), FL2FXCONST_DMX(0.3333333333333333f)}};
+
+#define TYPE_NONE (0x00)
+#define TYPE_PCE_DATA (0x01)
+#define TYPE_DSE_CLEV_DATA (0x02)
+#define TYPE_DSE_SLEV_DATA (0x04)
+#define TYPE_DSE_DMIX_AB_DATA (0x08)
+#define TYPE_DSE_DMIX_LFE_DATA (0x10)
+#define TYPE_DSE_DMX_GAIN_DATA (0x20)
+#define TYPE_DSE_DMX_CGL_DATA (0x40)
+#define TYPE_DSE_DATA (0x7E)
+
+typedef struct {
+  UINT typeFlags;
+  /* From DSE */
+  UCHAR cLevIdx;
+  UCHAR sLevIdx;
+  UCHAR dmixIdxA;
+  UCHAR dmixIdxB;
+  UCHAR dmixIdxLfe;
+  UCHAR dmxGainIdx2;
+  UCHAR dmxGainIdx5;
+  /* From PCE */
+  UCHAR matrixMixdownIdx;
+  /* Attributes: */
+  SCHAR pseudoSurround; /*!< If set to 1 the signal is pseudo surround
+                           compatible. The value 0 tells that it is not. If the
+                           value is -1 the information is not available.  */
+  UINT expiryCount; /*!< Counter to monitor the life time of a meta data set. */
+
+} DMX_BS_META_DATA;
+
+/* Default metadata */
+static const DMX_BS_META_DATA dfltMetaData = {0, 2, 2, 2,  2, 15,
+                                              0, 0, 0, -1, 0};
+
+/* Dynamic (user) params:
+     See the definition of PCMDMX_PARAM for details on the specific fields. */
+typedef struct {
+  DMX_PROFILE_TYPE dmxProfile; /*!< Linked to DMX_PRFL_STANDARD              */
+  UINT expiryFrame;            /*!< Linked to DMX_BS_DATA_EXPIRY_FRAME       */
+  DUAL_CHANNEL_MODE dualChannelMode; /*!< Linked to DMX_DUAL_CHANNEL_MODE */
+  PSEUDO_SURROUND_MODE
+  pseudoSurrMode;          /*!< Linked to DMX_PSEUDO_SURROUND_MODE       */
+  SHORT numOutChannelsMin; /*!< Linked to MIN_NUMBER_OF_OUTPUT_CHANNELS  */
+  SHORT numOutChannelsMax; /*!< Linked to MAX_NUMBER_OF_OUTPUT_CHANNELS  */
+  UCHAR frameDelay;        /*!< Linked to DMX_BS_DATA_DELAY              */
+
+} PCM_DMX_USER_PARAMS;
+
+/* Modules main data structure: */
+struct PCM_DMX_INSTANCE {
+  /* Metadata */
+  DMX_BS_META_DATA bsMetaData[(1) + 1];
+  PCM_DMX_USER_PARAMS userParams;
+
+  UCHAR applyProcessing; /*!< Flag to en-/disable modules processing.
+                              The max channel limiting is done independently. */
+};
+
+/* Memory allocation macro */
+C_ALLOC_MEM(PcmDmxInstance, struct PCM_DMX_INSTANCE, 1)
+
+static UINT getSpeakerDistance(PCM_DMX_SPEAKER_POSITION posA,
+                               PCM_DMX_SPEAKER_POSITION posB) {
+  PCM_DMX_SPEAKER_POSITION diff;
+
+  diff.x = posA.x - posB.x;
+  diff.y = posA.y - posB.y;
+  diff.z = posA.z - posB.z;
+
+  return ((diff.x * diff.x) + (diff.y * diff.y) + (diff.z * diff.z));
+}
+
+static PCM_DMX_SPEAKER_POSITION getSpeakerPos(AUDIO_CHANNEL_TYPE chType,
+                                              UCHAR chIndex, UCHAR numChInGrp) {
+#define PCMDMX_SPKR_POS_X_MAX_WIDTH (3)
+#define PCMDMX_SPKR_POS_Y_SPREAD (2)
+#define PCMDMX_SPKR_POS_Z_SPREAD (2)
+
+  PCM_DMX_SPEAKER_POSITION spkrPos = {0, 0, 0};
+  AUDIO_CHANNEL_TYPE chGrp = (AUDIO_CHANNEL_TYPE)(chType & 0x0F);
+  unsigned fHasCenter = numChInGrp & 0x1;
+  unsigned chGrpWidth = numChInGrp >> 1;
+  unsigned fIsCenter = 0;
+  unsigned fIsLfe = (chType == ACT_LFE) ? 1 : 0;
+  int offset = 0;
+
+  FDK_ASSERT(chIndex < numChInGrp);
+
+  if ((chGrp == ACT_FRONT) && fHasCenter) {
+    if (chIndex == 0) fIsCenter = 1;
+    chIndex = (UCHAR)fMax(0, chIndex - 1);
+  } else if (fHasCenter && (chIndex == numChInGrp - 1)) {
+    fIsCenter = 1;
+  }
+  /* now all even indices are left (-) */
+  if (!fIsCenter) {
+    offset = chIndex >> 1;
+    if ((chGrp > ACT_FRONT) && (chType != ACT_SIDE) && !fIsLfe) {
+      /* the higher the index the lower the distance to the center position */
+      offset = chGrpWidth - fHasCenter - offset;
+    }
+    if ((chIndex & 0x1) == 0) { /* even */
+      offset = -(offset + 1);
+    } else {
+      offset += 1;
+    }
+  }
+  /* apply the offset */
+  if (chType == ACT_SIDE) {
+    spkrPos.x = (offset < 0) ? -PCMDMX_SPKR_POS_X_MAX_WIDTH
+                             : PCMDMX_SPKR_POS_X_MAX_WIDTH;
+    spkrPos.y = /* 1x */ PCMDMX_SPKR_POS_Y_SPREAD + (SCHAR)fAbs(offset) - 1;
+    spkrPos.z = 0;
+  } else {
+    unsigned spread =
+        ((chGrpWidth == 1) && (!fIsLfe)) ? PCMDMX_SPKR_POS_X_MAX_WIDTH - 1 : 1;
+    spkrPos.x = (SCHAR)offset * (SCHAR)spread;
+    if (fIsLfe) {
+      spkrPos.y = 0;
+      spkrPos.z = SP_Z_LFE;
+    } else {
+      spkrPos.y = (SCHAR)fMax((SCHAR)chGrp - 1, 0) * PCMDMX_SPKR_POS_Y_SPREAD;
+      spkrPos.z = (SCHAR)chType >> 4;
+      if (spkrPos.z == 2) { /* ACT_BOTTOM */
+        spkrPos.z = -1;
+      }
+      spkrPos.z *= PCMDMX_SPKR_POS_Z_SPREAD;
+    }
+  }
+  return spkrPos;
+}
+
+/** Return the channel mode of a given horizontal channel plain (normal, top,
+ *bottom) for a given channel configuration. NOTE: This function shall get
+ *obsolete once the channel mode has been changed to be nonambiguous.
+ * @param [in] Index of the requested channel plain.
+ * @param [in] The packed channel mode for the complete channel configuration
+ *(all plains).
+ * @param [in] The MPEG-4 channel configuration index which is necessary in
+ *cases where the (packed) channel mode is ambiguous.
+ * @returns Returns the packed channel mode of the requested channel plain.
+ **/
+static PCM_DMX_CHANNEL_MODE getChMode4Plain(
+    const int plainIndex, const PCM_DMX_CHANNEL_MODE totChMode,
+    const int chCfg) {
+  PCM_DMX_CHANNEL_MODE plainChMode = totChMode;
+
+  switch (totChMode) {
+    case CH_MODE_5_0_2_1:
+      if (chCfg == 14) {
+        switch (plainIndex) {
+          case CH_PLAIN_BOTTOM:
+            plainChMode = (PCM_DMX_CHANNEL_MODE)0x0000;
+            break;
+          case CH_PLAIN_TOP:
+            plainChMode = CH_MODE_2_0_0_0;
+            break;
+          case CH_PLAIN_NORMAL:
+          default:
+            plainChMode = CH_MODE_3_0_2_1;
+            break;
+        }
+      }
+      break;
+    default:
+      break;
+  }
+
+  return plainChMode;
+}
+
+static inline UINT getIdxSum(UCHAR numCh) {
+  UINT result = 0;
+  int i;
+  for (i = 1; i < numCh; i += 1) {
+    result += i;
+  }
+  return result;
+}
+
+/** Evaluate a given channel configuration and extract a packed channel mode. In
+ *addition the function generates a channel offset table for the mapping to the
+ *internal representation. This function is the inverse to the
+ *getChannelDescription() routine.
+ * @param [in] The total number of channels of the given configuration.
+ * @param [in] Array holding the corresponding channel types for each channel.
+ * @param [in] Array holding the corresponding channel type indices for each
+ *channel.
+ * @param [out] Array where the buffer offsets for each channel are stored into.
+ * @param [out] The generated packed channel mode that represents the given
+ *input configuration.
+ * @returns Returns an error code.
+ **/
+static PCMDMX_ERROR getChannelMode(
+    const UINT numChannels,                 /* in */
+    const AUDIO_CHANNEL_TYPE channelType[], /* in */
+    UCHAR channelIndices[],                 /* in */
+    UCHAR offsetTable[(8)],                 /* out */
+    PCM_DMX_CHANNEL_MODE *chMode            /* out */
+) {
+  UINT idxSum[(3)][(4)];
+  UCHAR numCh[(3)][(4)];
+  UCHAR mapped[(8)];
+  PCM_DMX_SPEAKER_POSITION spkrPos[(8)];
+  PCMDMX_ERROR err = PCMDMX_OK;
+  unsigned ch, numMappedInChs = 0;
+  unsigned startSlot;
+  unsigned stopSlot = LOW_FREQUENCY_CHANNEL;
+
+  FDK_ASSERT(channelType != NULL);
+  FDK_ASSERT(channelIndices != NULL);
+  FDK_ASSERT(offsetTable != NULL);
+  FDK_ASSERT(chMode != NULL);
+
+  /* For details see ISO/IEC 13818-7:2005(E), 8.5.3 Channel configuration */
+  FDKmemclear(idxSum, (3) * (4) * sizeof(UINT));
+  FDKmemclear(numCh, (3) * (4) * sizeof(UCHAR));
+  FDKmemclear(mapped, (8) * sizeof(UCHAR));
+  FDKmemclear(spkrPos, (8) * sizeof(PCM_DMX_SPEAKER_POSITION));
+  /* Init output */
+  FDKmemset(offsetTable, 255, (8) * sizeof(UCHAR));
+  *chMode = CH_MODE_UNDEFINED;
+
+  /* Determine how many channels are assigned to each channels each group: */
+  for (ch = 0; ch < numChannels; ch += 1) {
+    unsigned chGrp = fMax(
+        (channelType[ch] & 0x0F) - 1,
+        0); /* Assign all undefined channels (ACT_NONE) to front channels. */
+    numCh[channelType[ch] >> 4][chGrp] += 1;
+    idxSum[channelType[ch] >> 4][chGrp] += channelIndices[ch];
+  }
+  if (numChannels > TWO_CHANNEL) {
+    int chGrp;
+    /* Sanity check on the indices */
+    for (chGrp = 0; chGrp < (4); chGrp += 1) {
+      int plane;
+      for (plane = 0; plane < (3); plane += 1) {
+        if (idxSum[plane][chGrp] != getIdxSum(numCh[plane][chGrp])) {
+          unsigned idxCnt = 0;
+          for (ch = 0; ch < numChannels; ch += 1) {
+            if (channelType[ch] ==
+                (AUDIO_CHANNEL_TYPE)((plane << 4) | ((chGrp + 1) & 0xF))) {
+              channelIndices[ch] = idxCnt++;
+            }
+          }
+          err = PCMDMX_INVALID_CH_CONFIG;
+        }
+      }
+    }
+  }
+  /* Mapping HEAT 1:
+   *   Determine the speaker position of each input channel and map it to a
+   * internal slot if it matches exactly (with zero distance). */
+  for (ch = 0; ch < numChannels; ch += 1) {
+    UINT mapDist = (unsigned)-1;
+    unsigned mapCh, mapPos = (unsigned)-1;
+    unsigned chGrp = fMax(
+        (channelType[ch] & 0x0F) - 1,
+        0); /* Assign all undefined channels (ACT_NONE) to front channels. */
+
+    spkrPos[ch] = getSpeakerPos(channelType[ch], channelIndices[ch],
+                                numCh[channelType[ch] >> 4][chGrp]);
+
+    for (mapCh = 0; mapCh <= stopSlot; mapCh += 1) {
+      if (offsetTable[mapCh] == 255) {
+        UINT dist = getSpeakerDistance(spkrPos[ch], spkrSlotPos[mapCh]);
+        if (dist < mapDist) {
+          mapPos = mapCh;
+          mapDist = dist;
+        }
+      }
+    }
+    if (mapDist <= PCMDMX_THRESHOLD_MAP_HEAT_1) {
+      offsetTable[mapPos] = (UCHAR)ch;
+      mapped[ch] = 1;
+      numMappedInChs += 1;
+    }
+  }
+
+  /* Mapping HEAT 2:
+   *   Go through the unmapped input channels and assign them to the internal
+   * slots that matches best (least distance). But assign center channels to
+   * center slots only. */
+  startSlot =
+      ((numCh[CH_PLAIN_NORMAL][CH_GROUP_FRONT] & 0x1) || (numChannels >= (8)))
+          ? 0
+          : 1;
+  for (ch = 0; ch < (unsigned)numChannels; ch += 1) {
+    if (!mapped[ch]) {
+      UINT mapDist = (unsigned)-1;
+      unsigned mapCh, mapPos = (unsigned)-1;
+
+      for (mapCh = startSlot; mapCh <= stopSlot; mapCh += 1) {
+        if (offsetTable[mapCh] == 255) {
+          UINT dist = getSpeakerDistance(spkrPos[ch], spkrSlotPos[mapCh]);
+          if (dist < mapDist) {
+            mapPos = mapCh;
+            mapDist = dist;
+          }
+        }
+      }
+      if ((mapPos <= stopSlot) && (mapDist < PCMDMX_THRESHOLD_MAP_HEAT_2) &&
+          (((spkrPos[ch].x != 0) && (spkrSlotPos[mapPos].x != 0)) /* XOR */
+           || ((spkrPos[ch].x == 0) &&
+               (spkrSlotPos[mapPos].x ==
+                0)))) { /* Assign center channels to center slots only. */
+        offsetTable[mapPos] = (UCHAR)ch;
+        mapped[ch] = 1;
+        numMappedInChs += 1;
+      }
+    }
+  }
+
+  /* Mapping HEAT 3:
+   *   Assign the rest by searching for the nearest input channel for each
+   * internal slot. */
+  for (ch = startSlot; (ch < (8)) && (numMappedInChs < numChannels); ch += 1) {
+    if (offsetTable[ch] == 255) {
+      UINT mapDist = (unsigned)-1;
+      unsigned mapCh, mapPos = (unsigned)-1;
+
+      for (mapCh = 0; mapCh < (unsigned)numChannels; mapCh += 1) {
+        if (!mapped[mapCh]) {
+          UINT dist = getSpeakerDistance(spkrPos[mapCh], spkrSlotPos[ch]);
+          if (dist < mapDist) {
+            mapPos = mapCh;
+            mapDist = dist;
+          }
+        }
+      }
+      if (mapDist < PCMDMX_THRESHOLD_MAP_HEAT_3) {
+        offsetTable[ch] = (UCHAR)mapPos;
+        mapped[mapPos] = 1;
+        numMappedInChs += 1;
+        if ((spkrPos[mapPos].x == 0) && (spkrSlotPos[ch].x != 0) &&
+            (numChannels <
+             (8))) { /* Skip the paired slot if we assigned a center channel. */
+          ch += 1;
+        }
+      }
+    }
+  }
+
+  /* Finaly compose the channel mode */
+  for (ch = 0; ch < (4); ch += 1) {
+    int plane, numChInGrp = 0;
+    for (plane = 0; plane < (3); plane += 1) {
+      numChInGrp += numCh[plane][ch];
+    }
+    *chMode = (PCM_DMX_CHANNEL_MODE)(*chMode | (numChInGrp << (ch * 4)));
+  }
+
+  return err;
+}
+
+/** Generate a channel offset table and complete channel description for a given
+ *(packed) channel mode. This function is the inverse to the getChannelMode()
+ *routine but does not support weird channel configurations.
+ * @param [in] The packed channel mode of the configuration to be processed.
+ * @param [in] Array containing the channel mapping to be used (From MPEG PCE
+ *ordering to whatever is required).
+ * @param [out] Array where corresponding channel types for each channels are
+ *stored into.
+ * @param [out] Array where corresponding channel type indices for each output
+ *channel are stored into.
+ * @param [out] Array where the buffer offsets for each channel are stored into.
+ * @returns None.
+ **/
+static void getChannelDescription(
+    const PCM_DMX_CHANNEL_MODE chMode,         /* in */
+    const FDK_channelMapDescr *const mapDescr, /* in */
+    AUDIO_CHANNEL_TYPE channelType[],          /* out */
+    UCHAR channelIndices[],                    /* out */
+    UCHAR offsetTable[(8)]                     /* out */
+) {
+  int grpIdx, plainIdx, numPlains = 1, numTotalChannels = 0;
+  int chCfg, ch = 0;
+
+  FDK_ASSERT(channelType != NULL);
+  FDK_ASSERT(channelIndices != NULL);
+  FDK_ASSERT(mapDescr != NULL);
+  FDK_ASSERT(offsetTable != NULL);
+
+  /* Init output arrays */
+  FDKmemclear(channelType, (8) * sizeof(AUDIO_CHANNEL_TYPE));
+  FDKmemclear(channelIndices, (8) * sizeof(UCHAR));
+  FDKmemset(offsetTable, 255, (8) * sizeof(UCHAR));
+
+  /* Summerize to get the total number of channels */
+  for (grpIdx = 0; grpIdx < (4); grpIdx += 1) {
+    numTotalChannels += (chMode >> (grpIdx * 4)) & 0xF;
+  }
+
+  /* Get the appropriate channel map */
+  switch (chMode) {
+    case CH_MODE_1_0_0_0:
+    case CH_MODE_2_0_0_0:
+    case CH_MODE_3_0_0_0:
+    case CH_MODE_3_0_1_0:
+    case CH_MODE_3_0_2_0:
+    case CH_MODE_3_0_2_1:
+      chCfg = numTotalChannels;
+      break;
+    case CH_MODE_3_0_3_1:
+      chCfg = 11;
+      break;
+    case CH_MODE_3_0_4_1:
+      chCfg = 12;
+      break;
+    case CH_MODE_5_0_2_1:
+      chCfg = 7;
+      break;
+    default:
+      /* fallback */
+      chCfg = 0;
+      break;
+  }
+
+  /* Compose channel offset table */
+
+  for (plainIdx = 0; plainIdx < numPlains; plainIdx += 1) {
+    PCM_DMX_CHANNEL_MODE plainChMode;
+    UCHAR numChInGrp[(4)];
+
+    plainChMode = getChMode4Plain(plainIdx, chMode, chCfg);
+
+    /* Extract the number of channels per group */
+    numChInGrp[CH_GROUP_FRONT] = plainChMode & 0xF;
+    numChInGrp[CH_GROUP_SIDE] = (plainChMode >> 4) & 0xF;
+    numChInGrp[CH_GROUP_REAR] = (plainChMode >> 8) & 0xF;
+    numChInGrp[CH_GROUP_LFE] = (plainChMode >> 12) & 0xF;
+
+    /* Non-symmetric channels */
+    if ((numChInGrp[CH_GROUP_FRONT] & 0x1) && (plainIdx == CH_PLAIN_NORMAL)) {
+      /* Odd number of front channels -> we have a center channel.
+         In MPEG-4 the center has the index 0. */
+      int mappedIdx = FDK_chMapDescr_getMapValue(mapDescr, (UCHAR)ch, chCfg);
+      offsetTable[CENTER_FRONT_CHANNEL] = (UCHAR)mappedIdx;
+      channelType[mappedIdx] = ACT_FRONT;
+      channelIndices[mappedIdx] = 0;
+      ch += 1;
+    }
+
+    for (grpIdx = 0; grpIdx < (4); grpIdx += 1) {
+      AUDIO_CHANNEL_TYPE type = ACT_NONE;
+      int chMapPos = 0, maxChannels = 0;
+      int chIdx = 0; /* Index of channel within the specific group */
+
+      switch (grpIdx) {
+        case CH_GROUP_FRONT:
+          type = (AUDIO_CHANNEL_TYPE)((plainIdx << 4) | ACT_FRONT);
+          switch (plainIdx) {
+            default:
+              chMapPos = LEFT_FRONT_CHANNEL;
+              chIdx = numChInGrp[grpIdx] & 0x1;
+              break;
+          }
+          maxChannels = 3;
+          break;
+        case CH_GROUP_SIDE:
+          /* Always map side channels to the multipurpose group. */
+          type = (AUDIO_CHANNEL_TYPE)((plainIdx << 4) | ACT_SIDE);
+          if (plainIdx == CH_PLAIN_TOP) {
+            chMapPos = LEFT_SIDE_CHANNEL_TOP;
+            maxChannels = 3;
+          } else {
+            chMapPos = LEFT_MULTIPRPS_CHANNEL;
+            maxChannels = 2;
+          }
+          break;
+        case CH_GROUP_REAR:
+          type = (AUDIO_CHANNEL_TYPE)((plainIdx << 4) | ACT_BACK);
+          if (plainIdx == CH_PLAIN_TOP) {
+            chMapPos = LEFT_REAR_CHANNEL_TOP;
+            maxChannels = 3;
+          } else {
+            chMapPos = LEFT_REAR_CHANNEL;
+            maxChannels = 2;
+          }
+          break;
+        case CH_GROUP_LFE:
+          if (plainIdx == CH_PLAIN_NORMAL) {
+            type = ACT_LFE;
+            chMapPos = LOW_FREQUENCY_CHANNEL;
+            maxChannels = 1;
+          }
+          break;
+        default:
+          break;
+      }
+
+      /* Map all channels in this group */
+      for (; chIdx < numChInGrp[grpIdx]; chIdx += 1) {
+        int mappedIdx = FDK_chMapDescr_getMapValue(mapDescr, (UCHAR)ch, chCfg);
+        if ((chIdx == maxChannels) || (offsetTable[chMapPos] < 255)) {
+          /* No space left in this channel group! */
+          if (offsetTable[LEFT_MULTIPRPS_CHANNEL] ==
+              255) { /* Use the multipurpose group: */
+            chMapPos = LEFT_MULTIPRPS_CHANNEL;
+          } else {
+            FDK_ASSERT(0);
+          }
+        }
+        offsetTable[chMapPos] = (UCHAR)mappedIdx;
+        channelType[mappedIdx] = type;
+        channelIndices[mappedIdx] = (UCHAR)chIdx;
+        chMapPos += 1;
+        ch += 1;
+      }
+    }
+  }
+}
+
+/** Private helper function for downmix matrix manipulation that initializes
+ *  one row in a given downmix matrix (corresponding to one output channel).
+ * @param [inout] Pointer to fixed-point parts of the downmix matrix.
+ * @param [inout] Pointer to scale factor matrix associated to the downmix
+ *factors.
+ * @param [in]    Index of channel (row) to be initialized.
+ * @returns       Nothing to return.
+ **/
+static void dmxInitChannel(FIXP_DMX mixFactors[(8)][(8)],
+                           INT mixScales[(8)][(8)], const unsigned int outCh) {
+  unsigned int inCh;
+  for (inCh = 0; inCh < (8); inCh += 1) {
+    if (inCh == outCh) {
+      mixFactors[outCh][inCh] = FL2FXCONST_DMX(0.5f);
+      mixScales[outCh][inCh] = 1;
+    } else {
+      mixFactors[outCh][inCh] = FL2FXCONST_DMX(0.0f);
+      mixScales[outCh][inCh] = 0;
+    }
+  }
+}
+
+/** Private helper function for downmix matrix manipulation that does a reset
+ *  of one row in a given downmix matrix (corresponding to one output channel).
+ * @param [inout] Pointer to fixed-point parts of the downmix matrix.
+ * @param [inout] Pointer to scale factor matrix associated to the downmix
+ *factors.
+ * @param [in]    Index of channel (row) to be cleared/reset.
+ * @returns       Nothing to return.
+ **/
+static void dmxClearChannel(FIXP_DMX mixFactors[(8)][(8)],
+                            INT mixScales[(8)][(8)], const unsigned int outCh) {
+  FDK_ASSERT((outCh >= 0) && (outCh < (8)));
+  FDKmemclear(&mixFactors[outCh], (8) * sizeof(FIXP_DMX));
+  FDKmemclear(&mixScales[outCh], (8) * sizeof(INT));
+}
+
+/** Private helper function for downmix matrix manipulation that applies a
+ *source channel (row) scaled by a given mix factor to a destination channel
+ *(row) in a given downmix matrix. Existing mix factors of the destination
+ *channel (row) will get overwritten.
+ * @param [inout] Pointer to fixed-point parts of the downmix matrix.
+ * @param [inout] Pointer to scale factor matrix associated to the downmix
+ *factors.
+ * @param [in]    Index of source channel (row).
+ * @param [in]    Index of destination channel (row).
+ * @param [in]    Fixed-point part of mix factor to be applied.
+ * @param [in]    Scale factor of mix factor to be applied.
+ * @returns       Nothing to return.
+ **/
+static void dmxSetChannel(FIXP_DMX mixFactors[(8)][(8)],
+                          INT mixScales[(8)][(8)], const unsigned int dstCh,
+                          const unsigned int srcCh, const FIXP_DMX factor,
+                          const INT scale) {
+  int ch;
+  for (ch = 0; ch < (8); ch += 1) {
+    if (mixFactors[srcCh][ch] != (FIXP_DMX)0) {
+      mixFactors[dstCh][ch] =
+          FX_DBL2FX_DMX(fMult(mixFactors[srcCh][ch], factor));
+      mixScales[dstCh][ch] = mixScales[srcCh][ch] + scale;
+    }
+  }
+}
+
+/** Private helper function for downmix matrix manipulation that adds a source
+ *channel (row) scaled by a given mix factor to a destination channel (row) in a
+ *given downmix matrix.
+ * @param [inout] Pointer to fixed-point parts of the downmix matrix.
+ * @param [inout] Pointer to scale factor matrix associated to the downmix
+ *factors.
+ * @param [in]    Index of source channel (row).
+ * @param [in]    Index of destination channel (row).
+ * @param [in]    Fixed-point part of mix factor to be applied.
+ * @param [in]    Scale factor of mix factor to be applied.
+ * @returns       Nothing to return.
+ **/
+static void dmxAddChannel(FIXP_DMX mixFactors[(8)][(8)],
+                          INT mixScales[(8)][(8)], const unsigned int dstCh,
+                          const unsigned int srcCh, const FIXP_DMX factor,
+                          const INT scale) {
+  int ch;
+  for (ch = 0; ch < (8); ch += 1) {
+    FIXP_DBL addFact = fMult(mixFactors[srcCh][ch], factor);
+    if (addFact != (FIXP_DMX)0) {
+      INT newScale = mixScales[srcCh][ch] + scale;
+      if (mixFactors[dstCh][ch] != (FIXP_DMX)0) {
+        if (newScale > mixScales[dstCh][ch]) {
+          mixFactors[dstCh][ch] >>= newScale - mixScales[dstCh][ch];
+        } else {
+          addFact >>= mixScales[dstCh][ch] - newScale;
+          newScale = mixScales[dstCh][ch];
+        }
+      }
+      mixFactors[dstCh][ch] += FX_DBL2FX_DMX(addFact);
+      mixScales[dstCh][ch] = newScale;
+    }
+  }
+}
+
+/** Private function that creates a downmix factor matrix depending on the input
+ and output
+ *  configuration, the user parameters as well as the given metadata. This
+ function is the modules
+ *  brain and hold all downmix algorithms.
+ * @param [in]  Flag that indicates if inChMode holds a real (packed) channel
+ mode or has been converted to a MPEG-4 channel configuration index.
+ * @param [in]  Dependent on the inModeIsCfg flag this field hands in a (packed)
+ channel mode or the corresponding MPEG-4 channel configuration index.of the
+ input configuration.
+ * @param [in]  The (packed) channel mode of the output configuration.
+ * @param [in]  Pointer to structure holding all current user parameter.
+ * @param [in]  Pointer to field holding all current meta data.
+ * @param [out] Pointer to fixed-point parts of the downmix matrix. Normalized
+ to one scale factor.
+ * @param [out] The common scale factor of the downmix matrix.
+ * @returns     An error code.
+ **/
+static PCMDMX_ERROR getMixFactors(const UCHAR inModeIsCfg,
+                                  PCM_DMX_CHANNEL_MODE inChMode,
+                                  const PCM_DMX_CHANNEL_MODE outChMode,
+                                  const PCM_DMX_USER_PARAMS *pParams,
+                                  const DMX_BS_META_DATA *pMetaData,
+                                  FIXP_DMX mixFactors[(8)][(8)],
+                                  INT *pOutScale) {
+  PCMDMX_ERROR err = PCMDMX_OK;
+  INT mixScales[(8)][(8)];
+  INT maxScale = 0;
+  int numInChannel;
+  int numOutChannel;
+  int dmxMethod;
+  unsigned int outCh, inChCfg = 0;
+  unsigned int valid[(8)] = {0};
+
+  FDK_ASSERT(pMetaData != NULL);
+  FDK_ASSERT(mixFactors != NULL);
+  /* Check on a supported output configuration.
+     Add new one only after extensive testing! */
+  if (!((outChMode == CH_MODE_1_0_0_0) || (outChMode == CH_MODE_2_0_0_0) ||
+        (outChMode == CH_MODE_3_0_2_1) || (outChMode == CH_MODE_3_0_4_1) ||
+        (outChMode == CH_MODE_5_0_2_1))) {
+    FDK_ASSERT(0);
+  }
+
+  if (inModeIsCfg) {
+    /* Convert channel config to channel mode: */
+    inChCfg = (unsigned int)inChMode;
+    switch (inChCfg) {
+      case 1:
+      case 2:
+      case 3:
+      case 4:
+      case 5:
+      case 6:
+        inChMode = outChModeTable[inChCfg];
+        break;
+      case 11:
+        inChMode = CH_MODE_3_0_3_1;
+        break;
+      case 12:
+        inChMode = CH_MODE_3_0_4_1;
+        break;
+      case 7:
+      case 14:
+        inChMode = CH_MODE_5_0_2_1;
+        break;
+      default:
+        FDK_ASSERT(0);
+    }
+  }
+
+  /* Extract the total number of input channels */
+  numInChannel = (inChMode & 0xF) + ((inChMode >> 4) & 0xF) +
+                 ((inChMode >> 8) & 0xF) + ((inChMode >> 12) & 0xF);
+  /* Extract the total number of output channels */
+  numOutChannel = (outChMode & 0xF) + ((outChMode >> 4) & 0xF) +
+                  ((outChMode >> 8) & 0xF) + ((outChMode >> 12) & 0xF);
+
+  /* MPEG ammendment 4 aka ETSI metadata and fallback mode: */
+
+  /* Create identity DMX matrix: */
+  for (outCh = 0; outCh < (8); outCh += 1) {
+    dmxInitChannel(mixFactors, mixScales, outCh);
+  }
+  if (((inChMode >> 12) & 0xF) == 0) {
+    /* Clear empty or wrongly mapped input channel */
+    dmxClearChannel(mixFactors, mixScales, LOW_FREQUENCY_CHANNEL);
+  }
+
+  /* FIRST STAGE: */
+  if (numInChannel > SIX_CHANNEL) { /* Always use MPEG equations either with
+                                       meta data or with default values. */
+    FIXP_DMX dMixFactA, dMixFactB;
+    INT dMixScaleA, dMixScaleB;
+    int isValidCfg = TRUE;
+
+    /* Get factors from meta data */
+    dMixFactA = abMixLvlValueTab[pMetaData->dmixIdxA];
+    dMixScaleA = (pMetaData->dmixIdxA == 0) ? 1 : 0;
+    dMixFactB = abMixLvlValueTab[pMetaData->dmixIdxB];
+    dMixScaleB = (pMetaData->dmixIdxB == 0) ? 1 : 0;
+
+    /* Check if input is in the list of supported configurations */
+    switch (inChMode) {
+      case CH_MODE_3_2_1_1: /* chCfg 11 but with side channels */
+      case CH_MODE_3_2_1_0:
+        isValidCfg = FALSE;
+        err = PCMDMX_INVALID_MODE;
+        FDK_FALLTHROUGH;
+      case CH_MODE_3_0_3_1: /* chCfg 11 */
+        /* 6.1ch:  C' = C;  L' = L;  R' = R;  LFE' = LFE;
+                   Ls' = Ls*dmix_a_idx + Cs*dmix_b_idx;
+                   Rs' = Rs*dmix_a_idx + Cs*dmix_b_idx; */
+        dmxClearChannel(
+            mixFactors, mixScales,
+            RIGHT_MULTIPRPS_CHANNEL); /* clear empty input channel */
+        dmxSetChannel(mixFactors, mixScales, LEFT_REAR_CHANNEL,
+                      LEFT_REAR_CHANNEL, dMixFactA, dMixScaleA);
+        dmxSetChannel(mixFactors, mixScales, LEFT_REAR_CHANNEL,
+                      LEFT_MULTIPRPS_CHANNEL, dMixFactB, dMixScaleB);
+        dmxSetChannel(mixFactors, mixScales, RIGHT_REAR_CHANNEL,
+                      RIGHT_REAR_CHANNEL, dMixFactA, dMixScaleA);
+        dmxSetChannel(mixFactors, mixScales, RIGHT_REAR_CHANNEL,
+                      LEFT_MULTIPRPS_CHANNEL, dMixFactB, dMixScaleB);
+        break;
+      case CH_MODE_3_0_4_1: /* chCfg 12 */
+        /* 7.1ch Surround Back:  C' = C;  L' = L;  R' = R;  LFE' = LFE;
+                                 Ls' = Ls*dmix_a_idx + Lsr*dmix_b_idx;
+                                 Rs' = Rs*dmix_a_idx + Rsr*dmix_b_idx; */
+        dmxSetChannel(mixFactors, mixScales, LEFT_REAR_CHANNEL,
+                      LEFT_REAR_CHANNEL, dMixFactA, dMixScaleA);
+        dmxSetChannel(mixFactors, mixScales, LEFT_REAR_CHANNEL,
+                      LEFT_MULTIPRPS_CHANNEL, dMixFactB, dMixScaleB);
+        dmxSetChannel(mixFactors, mixScales, RIGHT_REAR_CHANNEL,
+                      RIGHT_REAR_CHANNEL, dMixFactA, dMixScaleA);
+        dmxSetChannel(mixFactors, mixScales, RIGHT_REAR_CHANNEL,
+                      RIGHT_MULTIPRPS_CHANNEL, dMixFactB, dMixScaleB);
+        break;
+      case CH_MODE_5_0_1_0:
+      case CH_MODE_5_0_1_1:
+        dmxClearChannel(mixFactors, mixScales,
+                        RIGHT_REAR_CHANNEL); /* clear empty input channel */
+        dmxSetChannel(mixFactors, mixScales, RIGHT_REAR_CHANNEL,
+                      LEFT_REAR_CHANNEL, FL2FXCONST_DMX(0.5f), 1);
+        dmxSetChannel(mixFactors, mixScales, LEFT_REAR_CHANNEL,
+                      LEFT_REAR_CHANNEL, FL2FXCONST_DMX(0.5f), 1);
+        FDK_FALLTHROUGH;
+      case CH_MODE_5_2_1_0:
+        isValidCfg = FALSE;
+        err = PCMDMX_INVALID_MODE;
+        FDK_FALLTHROUGH;
+      case CH_MODE_5_0_2_1: /* chCfg 7 || 14 */
+        if (inChCfg == 14) {
+          /* 7.1ch Front Height:  C' = C;  Ls' = Ls;  Rs' = Rs;  LFE' = LFE;
+                                  L' = L*dmix_a_idx + Lv*dmix_b_idx;
+                                  R' = R*dmix_a_idx + Rv*dmix_b_idx; */
+          dmxSetChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                        LEFT_FRONT_CHANNEL, dMixFactA, dMixScaleA);
+          dmxSetChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                        LEFT_MULTIPRPS_CHANNEL, dMixFactB, dMixScaleB);
+          dmxSetChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                        RIGHT_FRONT_CHANNEL, dMixFactA, dMixScaleA);
+          dmxSetChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                        RIGHT_MULTIPRPS_CHANNEL, dMixFactB, dMixScaleB);
+        } else {
+          /* 7.1ch Front:  Ls' = Ls;  Rs' = Rs;  LFE' = LFE;
+                           C' = C + (Lc+Rc)*dmix_a_idx;
+                           L' = L + Lc*dmix_b_idx;
+                           R' = R + Rc*dmix_b_idx; */
+          dmxSetChannel(mixFactors, mixScales, CENTER_FRONT_CHANNEL,
+                        LEFT_MULTIPRPS_CHANNEL, dMixFactA, dMixScaleA);
+          dmxSetChannel(mixFactors, mixScales, CENTER_FRONT_CHANNEL,
+                        RIGHT_MULTIPRPS_CHANNEL, dMixFactA, dMixScaleA);
+          dmxSetChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                        LEFT_MULTIPRPS_CHANNEL, dMixFactB, dMixScaleB);
+          dmxSetChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                        LEFT_FRONT_CHANNEL, FL2FXCONST_DMX(0.5f), 1);
+          dmxSetChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                        RIGHT_MULTIPRPS_CHANNEL, dMixFactB, dMixScaleB);
+          dmxSetChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                        RIGHT_FRONT_CHANNEL, FL2FXCONST_DMX(0.5f), 1);
+        }
+        break;
+      default:
+        /* Nothing to do. Just use the identity matrix. */
+        isValidCfg = FALSE;
+        err = PCMDMX_INVALID_MODE;
+        break;
+    }
+
+    /* Add additional DMX gain */
+    if ((isValidCfg == TRUE) &&
+        (pMetaData->dmxGainIdx5 != 0)) { /* Apply DMX gain 5 */
+      FIXP_DMX dmxGain;
+      INT dmxScale;
+      INT sign = (pMetaData->dmxGainIdx5 & 0x40) ? -1 : 1;
+      INT val = pMetaData->dmxGainIdx5 & 0x3F;
+
+      /* 10^(dmx_gain_5/80) */
+      dmxGain = FX_DBL2FX_DMX(
+          fLdPow(FL2FXCONST_DBL(0.830482023721841f), 2, /* log2(10) */
+                 (FIXP_DBL)(sign * val * (LONG)FL2FXCONST_DBL(0.0125f)), 0,
+                 &dmxScale));
+      /* Currently only positive scale factors supported! */
+      if (dmxScale < 0) {
+        dmxGain >>= -dmxScale;
+        dmxScale = 0;
+      }
+
+      dmxSetChannel(mixFactors, mixScales, CENTER_FRONT_CHANNEL,
+                    CENTER_FRONT_CHANNEL, dmxGain, dmxScale);
+      dmxSetChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                    LEFT_FRONT_CHANNEL, dmxGain, dmxScale);
+      dmxSetChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                    RIGHT_FRONT_CHANNEL, dmxGain, dmxScale);
+      dmxSetChannel(mixFactors, mixScales, LEFT_REAR_CHANNEL, LEFT_REAR_CHANNEL,
+                    dmxGain, dmxScale);
+      dmxSetChannel(mixFactors, mixScales, RIGHT_REAR_CHANNEL,
+                    RIGHT_REAR_CHANNEL, dmxGain, dmxScale);
+      dmxSetChannel(mixFactors, mixScales, LOW_FREQUENCY_CHANNEL,
+                    LOW_FREQUENCY_CHANNEL, dmxGain, dmxScale);
+    }
+
+    /* Mark the output channels */
+    valid[CENTER_FRONT_CHANNEL] = 1;
+    valid[LEFT_FRONT_CHANNEL] = 1;
+    valid[RIGHT_FRONT_CHANNEL] = 1;
+    valid[LEFT_REAR_CHANNEL] = 1;
+    valid[RIGHT_REAR_CHANNEL] = 1;
+    valid[LOW_FREQUENCY_CHANNEL] = 1;
+
+    /* Update channel mode for the next stage */
+    inChMode = CH_MODE_3_0_2_1;
+  }
+
+    /* For the X (> 6) to 6 channel downmix we had no choice.
+       To mix from 6 to 2 (or 1) channel(s) we have several possibilities (MPEG
+       DSE | MPEG PCE | ITU | ARIB | DLB). Use profile and the metadata
+       available flags to determine which equation to use: */
+
+#define DMX_METHOD_MPEG_AMD4 1
+#define DMX_METHOD_MPEG_LEGACY 2
+#define DMX_METHOD_ARIB_JAPAN 4
+#define DMX_METHOD_ITU_RECOM 8
+#define DMX_METHOD_CUSTOM 16
+
+  dmxMethod = DMX_METHOD_MPEG_AMD4; /* default */
+
+  if ((pParams->dmxProfile == DMX_PRFL_FORCE_MATRIX_MIX) &&
+      (pMetaData->typeFlags & TYPE_PCE_DATA)) {
+    dmxMethod = DMX_METHOD_MPEG_LEGACY;
+  } else if (!(pMetaData->typeFlags &
+               (TYPE_DSE_CLEV_DATA | TYPE_DSE_SLEV_DATA))) {
+    switch (pParams->dmxProfile) {
+      default:
+      case DMX_PRFL_STANDARD:
+        /* dmxMethod = DMX_METHOD_MPEG_AMD4; */
+        break;
+      case DMX_PRFL_MATRIX_MIX:
+      case DMX_PRFL_FORCE_MATRIX_MIX:
+        if (pMetaData->typeFlags & TYPE_PCE_DATA) {
+          dmxMethod = DMX_METHOD_MPEG_LEGACY;
+        }
+        break;
+      case DMX_PRFL_ARIB_JAPAN:
+        dmxMethod = DMX_METHOD_ARIB_JAPAN;
+        break;
+    }
+  }
+
+  /* SECOND STAGE: */
+  if (numOutChannel <= TWO_CHANNEL) {
+    /* Create DMX matrix according to input configuration */
+    switch (inChMode) {
+      case CH_MODE_2_0_0_0: /* chCfg 2 */
+        /* Apply the dual channel mode. */
+        switch (pParams->dualChannelMode) {
+          case CH1_MODE: /* L' = 0.707 * Ch1;
+                            R' = 0.707 * Ch1; */
+            dmxSetChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                          LEFT_FRONT_CHANNEL, FL2FXCONST_DMX(0.707f), 0);
+            dmxSetChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                          LEFT_FRONT_CHANNEL, FL2FXCONST_DMX(0.707f), 0);
+            break;
+          case CH2_MODE: /* L' = 0.707 * Ch2;
+                            R' = 0.707 * Ch2; */
+            dmxSetChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                          RIGHT_FRONT_CHANNEL, FL2FXCONST_DMX(0.707f), 0);
+            dmxSetChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                          RIGHT_FRONT_CHANNEL, FL2FXCONST_DMX(0.707f), 0);
+            break;
+          case MIXED_MODE: /* L' = 0.5*Ch1 + 0.5*Ch2;
+                              R' = 0.5*Ch1 + 0.5*Ch2; */
+            dmxSetChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                          LEFT_FRONT_CHANNEL, FL2FXCONST_DMX(0.5f), 0);
+            dmxAddChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                          RIGHT_FRONT_CHANNEL, FL2FXCONST_DMX(0.5f), 0);
+            dmxSetChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                          LEFT_FRONT_CHANNEL, FL2FXCONST_DMX(0.5f), 0);
+            dmxAddChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                          RIGHT_FRONT_CHANNEL, FL2FXCONST_DMX(0.5f), 0);
+            break;
+          default:
+          case STEREO_MODE:
+            /* Nothing to do */
+            break;
+        }
+        break;
+      /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+       * - - - - - - - - - - - - - - - - - - - */
+      case CH_MODE_2_0_1_0: {
+        FIXP_DMX sMixLvl;
+        if (dmxMethod == DMX_METHOD_ARIB_JAPAN) {
+          /* L' = 0.707*L + 0.5*S;  R' = 0.707*R + 0.5*S; */
+          dmxSetChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                        LEFT_FRONT_CHANNEL, FL2FXCONST_DMX(0.707f), 0);
+          dmxSetChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                        RIGHT_FRONT_CHANNEL, FL2FXCONST_DMX(0.707f), 0);
+          sMixLvl = FL2FXCONST_DMX(0.5f);
+        } else { /* L' = L + 0.707*S;  R' = R + 0.707*S; */
+          sMixLvl = FL2FXCONST_DMX(0.707f);
+        }
+        dmxAddChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                      LEFT_REAR_CHANNEL, sMixLvl, 0);
+        dmxAddChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                      LEFT_REAR_CHANNEL, sMixLvl, 0);
+      } break;
+      /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+       * - - - - - - - - - - - - - - - - - - - */
+      case CH_MODE_3_0_0_0: /* chCfg 3 */
+      {
+        FIXP_DMX cMixLvl;
+        if (dmxMethod == DMX_METHOD_ARIB_JAPAN) {
+          /* L' = 0.707*L + 0.5*C;  R' = 0.707*R + 0.5*C; */
+          dmxSetChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                        LEFT_FRONT_CHANNEL, FL2FXCONST_DMX(0.707f), 0);
+          dmxSetChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                        RIGHT_FRONT_CHANNEL, FL2FXCONST_DMX(0.707f), 0);
+          cMixLvl = FL2FXCONST_DMX(0.5f);
+        } else { /* L' = L + 0.707*C;  R' = R + 0.707*C; */
+          cMixLvl = FL2FXCONST_DMX(0.707f);
+        }
+        dmxAddChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                      CENTER_FRONT_CHANNEL, cMixLvl, 0);
+        dmxAddChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                      CENTER_FRONT_CHANNEL, cMixLvl, 0);
+      } break;
+      /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+       * - - - - - - - - - - - - - - - - - - - */
+      case CH_MODE_3_0_1_0: /* chCfg 4 */
+      {
+        FIXP_DMX csMixLvl;
+        if (dmxMethod == DMX_METHOD_ARIB_JAPAN) {
+          /* L' = 0.707*L + 0.5*C + 0.5*S;  R' = 0.707*R + 0.5*C + 0.5*S; */
+          dmxSetChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                        LEFT_FRONT_CHANNEL, FL2FXCONST_DMX(0.707f), 0);
+          dmxSetChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                        RIGHT_FRONT_CHANNEL, FL2FXCONST_DMX(0.707f), 0);
+          csMixLvl = FL2FXCONST_DMX(0.5f);
+        } else { /* L' = L + 0.707*C + 0.707*S;
+                    R' = R + 0.707*C + 0.707*S; */
+          csMixLvl = FL2FXCONST_DMX(0.707f);
+        }
+        dmxAddChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                      CENTER_FRONT_CHANNEL, csMixLvl, 0);
+        dmxAddChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                      LEFT_REAR_CHANNEL, csMixLvl, 0);
+        dmxAddChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                      CENTER_FRONT_CHANNEL, csMixLvl, 0);
+        dmxAddChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                      LEFT_REAR_CHANNEL, csMixLvl, 0);
+      } break;
+      /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+       * - - - - - - - - - - - - - - - - - - - */
+      case CH_MODE_3_0_2_0: /* chCfg 5 */
+      case CH_MODE_3_0_2_1: /* chCfg 6 */
+      {
+        switch (dmxMethod) {
+          default:
+          case DMX_METHOD_MPEG_AMD4: {
+            FIXP_DMX cMixLvl, sMixLvl, lMixLvl;
+            INT cMixScale, sMixScale, lMixScale;
+
+            /* Get factors from meta data */
+            cMixLvl = abMixLvlValueTab[pMetaData->cLevIdx];
+            cMixScale = (pMetaData->cLevIdx == 0) ? 1 : 0;
+            sMixLvl = abMixLvlValueTab[pMetaData->sLevIdx];
+            sMixScale = (pMetaData->sLevIdx == 0) ? 1 : 0;
+            lMixLvl = lfeMixLvlValueTab[pMetaData->dmixIdxLfe];
+            if (pMetaData->dmixIdxLfe <= 1) {
+              lMixScale = 2;
+            } else if (pMetaData->dmixIdxLfe <= 5) {
+              lMixScale = 1;
+            } else {
+              lMixScale = 0;
+            }
+            /* Setup the DMX matrix */
+            if ((pParams->pseudoSurrMode == FORCE_PS_DMX) ||
+                ((pParams->pseudoSurrMode == AUTO_PS_DMX) &&
+                 (pMetaData->pseudoSurround ==
+                  1))) { /* L' = L + C*clev - (Ls+Rs)*slev + LFE*lflev;
+                            R' = R + C*clev + (Ls+Rs)*slev + LFE*lflev; */
+              dmxAddChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                            CENTER_FRONT_CHANNEL, cMixLvl, cMixScale);
+              dmxAddChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                            LEFT_REAR_CHANNEL, -sMixLvl, sMixScale);
+              dmxAddChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                            RIGHT_REAR_CHANNEL, -sMixLvl, sMixScale);
+              dmxAddChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                            LOW_FREQUENCY_CHANNEL, lMixLvl, lMixScale);
+              dmxAddChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                            CENTER_FRONT_CHANNEL, cMixLvl, cMixScale);
+              dmxAddChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                            LEFT_REAR_CHANNEL, sMixLvl, sMixScale);
+              dmxAddChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                            RIGHT_REAR_CHANNEL, sMixLvl, sMixScale);
+              dmxAddChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                            LOW_FREQUENCY_CHANNEL, lMixLvl, lMixScale);
+            } else { /* L' = L + C*clev + Ls*slev + LFE*llev;
+                        R' = R + C*clev + Rs*slev + LFE*llev; */
+              dmxAddChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                            CENTER_FRONT_CHANNEL, cMixLvl, cMixScale);
+              dmxAddChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                            LEFT_REAR_CHANNEL, sMixLvl, sMixScale);
+              dmxAddChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                            LOW_FREQUENCY_CHANNEL, lMixLvl, lMixScale);
+              dmxAddChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                            CENTER_FRONT_CHANNEL, cMixLvl, cMixScale);
+              dmxAddChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                            RIGHT_REAR_CHANNEL, sMixLvl, sMixScale);
+              dmxAddChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                            LOW_FREQUENCY_CHANNEL, lMixLvl, lMixScale);
+            }
+
+            /* Add additional DMX gain */
+            if (pMetaData->dmxGainIdx2 != 0) { /* Apply DMX gain 2 */
+              FIXP_DMX dmxGain;
+              INT dmxScale;
+              INT sign = (pMetaData->dmxGainIdx2 & 0x40) ? -1 : 1;
+              INT val = pMetaData->dmxGainIdx2 & 0x3F;
+
+              /* 10^(dmx_gain_2/80) */
+              dmxGain = FX_DBL2FX_DMX(
+                  fLdPow(FL2FXCONST_DBL(0.830482023721841f), 2, /* log2(10) */
+                         (FIXP_DBL)(sign * val * (LONG)FL2FXCONST_DBL(0.0125f)),
+                         0, &dmxScale));
+              /* Currently only positive scale factors supported! */
+              if (dmxScale < 0) {
+                dmxGain >>= -dmxScale;
+                dmxScale = 0;
+              }
+
+              dmxSetChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                            LEFT_FRONT_CHANNEL, dmxGain, dmxScale);
+              dmxSetChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                            RIGHT_FRONT_CHANNEL, dmxGain, dmxScale);
+            }
+          } break;
+          case DMX_METHOD_ARIB_JAPAN:
+          case DMX_METHOD_MPEG_LEGACY: {
+            FIXP_DMX flev, clev, slevLL, slevLR, slevRL, slevRR;
+            FIXP_DMX mtrxMixDwnCoef =
+                mpegMixDownIdx2Coef[pMetaData->matrixMixdownIdx];
+
+            if ((pParams->pseudoSurrMode == FORCE_PS_DMX) ||
+                ((pParams->pseudoSurrMode == AUTO_PS_DMX) &&
+                 (pMetaData->pseudoSurround == 1))) {
+              if (dmxMethod == DMX_METHOD_ARIB_JAPAN) {
+                /* 3/2 input: L' = 0.707 * [L+0.707*C-k*Ls-k*Rs];
+                              R' = 0.707 * [R+0.707*C+k*Ls+k*Rs]; */
+                flev = mpegMixDownIdx2Coef[0]; /* a = 0.707 */
+              } else { /* 3/2 input: L' = (1.707+2*A)^-1 *
+                          [L+0.707*C-A*Ls-A*Rs]; R' = (1.707+2*A)^-1 *
+                          [R+0.707*C+A*Ls+A*Rs]; */
+                flev = mpegMixDownIdx2PreFact[1][pMetaData->matrixMixdownIdx];
+              }
+              slevRR = slevRL = FX_DBL2FX_DMX(fMult(flev, mtrxMixDwnCoef));
+              slevLL = slevLR = -slevRL;
+            } else {
+              if (dmxMethod == DMX_METHOD_ARIB_JAPAN) {
+                /* 3/2 input: L' = 0.707 * [L+0.707*C+k*Ls];
+                              R' = 0.707 * [R+0.707*C+k*Rs]; */
+                flev = mpegMixDownIdx2Coef[0]; /* a = 0.707 */
+              } else { /* 3/2 input: L' = (1.707+A)^-1 * [L+0.707*C+A*Ls];
+                                     R' = (1.707+A)^-1 * [R+0.707*C+A*Rs]; */
+                flev = mpegMixDownIdx2PreFact[0][pMetaData->matrixMixdownIdx];
+              }
+              slevRR = slevLL = FX_DBL2FX_DMX(fMult(flev, mtrxMixDwnCoef));
+              slevLR = slevRL = (FIXP_DMX)0;
+            }
+            /* common factor */
+            clev =
+                FX_DBL2FX_DMX(fMult(flev, mpegMixDownIdx2Coef[0] /* 0.707 */));
+
+            dmxSetChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                          LEFT_FRONT_CHANNEL, flev, 0);
+            dmxAddChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                          CENTER_FRONT_CHANNEL, clev, 0);
+            dmxAddChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                          LEFT_REAR_CHANNEL, slevLL, 0);
+            dmxAddChannel(mixFactors, mixScales, LEFT_FRONT_CHANNEL,
+                          RIGHT_REAR_CHANNEL, slevLR, 0);
+
+            dmxSetChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                          RIGHT_FRONT_CHANNEL, flev, 0);
+            dmxAddChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                          CENTER_FRONT_CHANNEL, clev, 0);
+            dmxAddChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                          LEFT_REAR_CHANNEL, slevRL, 0);
+            dmxAddChannel(mixFactors, mixScales, RIGHT_FRONT_CHANNEL,
+                          RIGHT_REAR_CHANNEL, slevRR, 0);
+          } break;
+        } /* switch (dmxMethod) */
+      } break;
+      default:
+        /* This configuration does not fit to any known downmix equation! */
+        err = PCMDMX_INVALID_MODE;
+        break;
+    } /* switch (inChMode) */
+
+    /* Mark the output channels */
+    FDKmemclear(valid, (8) * sizeof(unsigned int));
+    valid[LEFT_FRONT_CHANNEL] = 1;
+    valid[RIGHT_FRONT_CHANNEL] = 1;
+  }
+
+  if (numOutChannel == ONE_CHANNEL) {
+    FIXP_DMX monoMixLevel;
+    INT monoMixScale = 0;
+
+    dmxClearChannel(mixFactors, mixScales,
+                    CENTER_FRONT_CHANNEL); /* C is not in the mix */
+
+    if (dmxMethod ==
+        DMX_METHOD_MPEG_LEGACY) { /* C' = (3+2*A)^-1 * [C+L+R+A*Ls+A+Rs]; */
+      monoMixLevel = mpegMixDownIdx2PreFact[2][pMetaData->matrixMixdownIdx];
+
+      mixFactors[CENTER_FRONT_CHANNEL][CENTER_FRONT_CHANNEL] = monoMixLevel;
+      mixFactors[CENTER_FRONT_CHANNEL][LEFT_FRONT_CHANNEL] = monoMixLevel;
+      mixFactors[CENTER_FRONT_CHANNEL][RIGHT_FRONT_CHANNEL] = monoMixLevel;
+      monoMixLevel = FX_DBL2FX_DMX(fMult(
+          monoMixLevel, mpegMixDownIdx2Coef[pMetaData->matrixMixdownIdx]));
+      mixFactors[CENTER_FRONT_CHANNEL][LEFT_REAR_CHANNEL] = monoMixLevel;
+      mixFactors[CENTER_FRONT_CHANNEL][RIGHT_REAR_CHANNEL] = monoMixLevel;
+    } else {
+      switch (dmxMethod) {
+        case DMX_METHOD_MPEG_AMD4:
+          /* C' = L + R; */
+          monoMixLevel = FL2FXCONST_DMX(0.5f);
+          monoMixScale = 1;
+          break;
+        default:
+          /* C' = 0.5*L + 0.5*R; */
+          monoMixLevel = FL2FXCONST_DMX(0.5f);
+          monoMixScale = 0;
+          break;
+      }
+      dmxSetChannel(mixFactors, mixScales, CENTER_FRONT_CHANNEL,
+                    LEFT_FRONT_CHANNEL, monoMixLevel, monoMixScale);
+      dmxAddChannel(mixFactors, mixScales, CENTER_FRONT_CHANNEL,
+                    RIGHT_FRONT_CHANNEL, monoMixLevel, monoMixScale);
+    }
+
+    /* Mark the output channel */
+    FDKmemclear(valid, (8) * sizeof(unsigned int));
+    valid[CENTER_FRONT_CHANNEL] = 1;
+  }
+
+#define MAX_SEARCH_START_VAL (-7)
+
+  {
+    LONG chSum[(8)];
+    INT chSumMax = MAX_SEARCH_START_VAL;
+
+    /* Determine the current maximum scale factor */
+    for (outCh = 0; outCh < (8); outCh += 1) {
+      if (valid[outCh] != 0) {
+        unsigned int inCh;
+        for (inCh = 0; inCh < (8); inCh += 1) {
+          if (mixScales[outCh][inCh] > maxScale) { /* Store the new maximum */
+            maxScale = mixScales[outCh][inCh];
+          }
+        }
+      }
+    }
+
+    /* Individualy analyse output chanal levels */
+    for (outCh = 0; outCh < (8); outCh += 1) {
+      chSum[outCh] = MAX_SEARCH_START_VAL;
+      if (valid[outCh] != 0) {
+        int ovrflwProtScale = 0;
+        unsigned int inCh;
+
+        /* Accumulate all factors for each output channel */
+        chSum[outCh] = 0;
+        for (inCh = 0; inCh < (8); inCh += 1) {
+          SHORT addFact = FX_DMX2SHRT(mixFactors[outCh][inCh]);
+          if (mixScales[outCh][inCh] <= maxScale) {
+            addFact >>= maxScale - mixScales[outCh][inCh];
+          } else {
+            addFact <<= mixScales[outCh][inCh] - maxScale;
+          }
+          chSum[outCh] += addFact;
+        }
+        if (chSum[outCh] > (LONG)MAXVAL_SGL) {
+          while (chSum[outCh] > (LONG)MAXVAL_SGL) {
+            ovrflwProtScale += 1;
+            chSum[outCh] >>= 1;
+          }
+        } else if (chSum[outCh] > 0) {
+          while ((chSum[outCh] << 1) <= (LONG)MAXVAL_SGL) {
+            ovrflwProtScale -= 1;
+            chSum[outCh] <<= 1;
+          }
+        }
+        /* Store the differential scaling in the same array */
+        chSum[outCh] = ovrflwProtScale;
+      }
+    }
+
+    for (outCh = 0; outCh < (8); outCh += 1) {
+      if ((valid[outCh] != 0) &&
+          (chSum[outCh] > chSumMax)) { /* Store the new maximum */
+        chSumMax = chSum[outCh];
+      }
+    }
+    maxScale = fMax(maxScale + chSumMax, 0);
+
+    /* Normalize all factors */
+    for (outCh = 0; outCh < (8); outCh += 1) {
+      if (valid[outCh] != 0) {
+        unsigned int inCh;
+        for (inCh = 0; inCh < (8); inCh += 1) {
+          if (mixFactors[outCh][inCh] != (FIXP_DMX)0) {
+            if (mixScales[outCh][inCh] <= maxScale) {
+              mixFactors[outCh][inCh] >>= maxScale - mixScales[outCh][inCh];
+            } else {
+              mixFactors[outCh][inCh] <<= mixScales[outCh][inCh] - maxScale;
+            }
+            mixScales[outCh][inCh] = maxScale;
+          }
+        }
+      }
+    }
+  }
+
+  /* return the scale factor */
+  *pOutScale = maxScale;
+
+  return (err);
+}
+
+/** Open and initialize an instance of the PCM downmix module
+ * @param [out] Pointer to a buffer receiving the handle of the new instance.
+ * @returns Returns an error code.
+ **/
+PCMDMX_ERROR pcmDmx_Open(HANDLE_PCM_DOWNMIX *pSelf) {
+  HANDLE_PCM_DOWNMIX self;
+
+  if (pSelf == NULL) {
+    return (PCMDMX_INVALID_HANDLE);
+  }
+
+  *pSelf = NULL;
+
+  self = (HANDLE_PCM_DOWNMIX)GetPcmDmxInstance(0);
+  if (self == NULL) {
+    return (PCMDMX_OUT_OF_MEMORY);
+  }
+
+  /* Reset the full instance */
+  pcmDmx_Reset(self, PCMDMX_RESET_FULL);
+
+  *pSelf = self;
+
+  return (PCMDMX_OK);
+}
+
+/** Reset all static values like e.g. mixdown coefficients.
+ * @param [in] Handle of PCM downmix module instance.
+ * @param [in] Flags telling which parts of the module shall be reset.
+ * @returns Returns an error code.
+ **/
+PCMDMX_ERROR pcmDmx_Reset(HANDLE_PCM_DOWNMIX self, UINT flags) {
+  if (self == NULL) {
+    return (PCMDMX_INVALID_HANDLE);
+  }
+
+  if (flags & PCMDMX_RESET_PARAMS) {
+    PCM_DMX_USER_PARAMS *pParams = &self->userParams;
+
+    pParams->dualChannelMode = STEREO_MODE;
+    pParams->pseudoSurrMode = NEVER_DO_PS_DMX;
+    pParams->numOutChannelsMax = (6);
+    pParams->numOutChannelsMin = (0);
+    pParams->frameDelay = 0;
+    pParams->expiryFrame = (0);
+
+    self->applyProcessing = 0;
+  }
+
+  if (flags & PCMDMX_RESET_BS_DATA) {
+    int slot;
+    /* Init all slots with a default set */
+    for (slot = 0; slot <= (1); slot += 1) {
+      FDKmemcpy(&self->bsMetaData[slot], &dfltMetaData,
+                sizeof(DMX_BS_META_DATA));
+    }
+  }
+
+  return (PCMDMX_OK);
+}
+
+/** Set one parameter for one instance of the PCM downmix module.
+ * @param [in] Handle of PCM downmix module instance.
+ * @param [in] Parameter to be set.
+ * @param [in] Parameter value.
+ * @returns Returns an error code.
+ **/
+PCMDMX_ERROR pcmDmx_SetParam(HANDLE_PCM_DOWNMIX self, const PCMDMX_PARAM param,
+                             const INT value) {
+  switch (param) {
+    case DMX_PROFILE_SETTING:
+      switch ((DMX_PROFILE_TYPE)value) {
+        case DMX_PRFL_STANDARD:
+        case DMX_PRFL_MATRIX_MIX:
+        case DMX_PRFL_FORCE_MATRIX_MIX:
+        case DMX_PRFL_ARIB_JAPAN:
+          break;
+        default:
+          return (PCMDMX_UNABLE_TO_SET_PARAM);
+      }
+      if (self == NULL) return (PCMDMX_INVALID_HANDLE);
+      self->userParams.dmxProfile = (DMX_PROFILE_TYPE)value;
+      break;
+
+    case DMX_BS_DATA_EXPIRY_FRAME:
+      if (self == NULL) return (PCMDMX_INVALID_HANDLE);
+      self->userParams.expiryFrame = (value > 0) ? (UINT)value : 0;
+      break;
+
+    case DMX_BS_DATA_DELAY:
+      if ((value > (1)) || (value < 0)) {
+        return (PCMDMX_UNABLE_TO_SET_PARAM);
+      }
+      if (self == NULL) {
+        return (PCMDMX_INVALID_HANDLE);
+      }
+      self->userParams.frameDelay = (UCHAR)value;
+      break;
+
+    case MIN_NUMBER_OF_OUTPUT_CHANNELS:
+      switch (value) { /* supported output channels */
+        case -1:
+        case 0:
+        case ONE_CHANNEL:
+        case TWO_CHANNEL:
+        case SIX_CHANNEL:
+        case EIGHT_CHANNEL:
+          break;
+        default:
+          return (PCMDMX_UNABLE_TO_SET_PARAM);
+      }
+      if (self == NULL) return (PCMDMX_INVALID_HANDLE);
+      /* Store the new value */
+      self->userParams.numOutChannelsMin = (value > 0) ? (SHORT)value : -1;
+      if ((value > 0) && (self->userParams.numOutChannelsMax > 0) &&
+          (value > self->userParams
+                       .numOutChannelsMax)) { /* MIN > MAX would be an invalid
+                                                 state. Thus set MAX = MIN in
+                                                 this case. */
+        self->userParams.numOutChannelsMax = self->userParams.numOutChannelsMin;
+      }
+      break;
+
+    case MAX_NUMBER_OF_OUTPUT_CHANNELS:
+      switch (value) { /* supported output channels */
+        case -1:
+        case 0:
+        case ONE_CHANNEL:
+        case TWO_CHANNEL:
+        case SIX_CHANNEL:
+        case EIGHT_CHANNEL:
+          break;
+        default:
+          return (PCMDMX_UNABLE_TO_SET_PARAM);
+      }
+      if (self == NULL) return (PCMDMX_INVALID_HANDLE);
+      /* Store the new value */
+      self->userParams.numOutChannelsMax = (value > 0) ? (SHORT)value : -1;
+      if ((value > 0) &&
+          (value < self->userParams
+                       .numOutChannelsMin)) { /* MAX < MIN would be an invalid
+                                                 state. Thus set MIN = MAX in
+                                                 this case. */
+        self->userParams.numOutChannelsMin = self->userParams.numOutChannelsMax;
+      }
+      break;
+
+    case DMX_DUAL_CHANNEL_MODE:
+      switch ((DUAL_CHANNEL_MODE)value) {
+        case STEREO_MODE:
+        case CH1_MODE:
+        case CH2_MODE:
+        case MIXED_MODE:
+          break;
+        default:
+          return (PCMDMX_UNABLE_TO_SET_PARAM);
+      }
+      if (self == NULL) return (PCMDMX_INVALID_HANDLE);
+      self->userParams.dualChannelMode = (DUAL_CHANNEL_MODE)value;
+      self->applyProcessing = ((DUAL_CHANNEL_MODE)value != STEREO_MODE)
+                                  ? 1
+                                  : 0; /* Force processing if necessary. */
+      break;
+
+    case DMX_PSEUDO_SURROUND_MODE:
+      switch ((PSEUDO_SURROUND_MODE)value) {
+        case NEVER_DO_PS_DMX:
+        case AUTO_PS_DMX:
+        case FORCE_PS_DMX:
+          break;
+        default:
+          return (PCMDMX_UNABLE_TO_SET_PARAM);
+      }
+      if (self == NULL) return (PCMDMX_INVALID_HANDLE);
+      self->userParams.pseudoSurrMode = (PSEUDO_SURROUND_MODE)value;
+      break;
+
+    default:
+      return (PCMDMX_UNKNOWN_PARAM);
+  }
+
+  return (PCMDMX_OK);
+}
+
+/** Get one parameter value of one PCM downmix module instance.
+ * @param [in] Handle of PCM downmix module instance.
+ * @param [in] Parameter to be set.
+ * @param [out] Pointer to buffer receiving the parameter value.
+ * @returns Returns an error code.
+ **/
+PCMDMX_ERROR pcmDmx_GetParam(HANDLE_PCM_DOWNMIX self, const PCMDMX_PARAM param,
+                             INT *const pValue) {
+  PCM_DMX_USER_PARAMS *pUsrParams;
+
+  if ((self == NULL) || (pValue == NULL)) {
+    return (PCMDMX_INVALID_HANDLE);
+  }
+  pUsrParams = &self->userParams;
+
+  switch (param) {
+    case DMX_PROFILE_SETTING:
+      *pValue = (INT)pUsrParams->dmxProfile;
+      break;
+    case DMX_BS_DATA_EXPIRY_FRAME:
+      *pValue = (INT)pUsrParams->expiryFrame;
+      break;
+    case DMX_BS_DATA_DELAY:
+      *pValue = (INT)pUsrParams->frameDelay;
+      break;
+    case MIN_NUMBER_OF_OUTPUT_CHANNELS:
+      *pValue = (INT)pUsrParams->numOutChannelsMin;
+      break;
+    case MAX_NUMBER_OF_OUTPUT_CHANNELS:
+      *pValue = (INT)pUsrParams->numOutChannelsMax;
+      break;
+    case DMX_DUAL_CHANNEL_MODE:
+      *pValue = (INT)pUsrParams->dualChannelMode;
+      break;
+    case DMX_PSEUDO_SURROUND_MODE:
+      *pValue = (INT)pUsrParams->pseudoSurrMode;
+      break;
+    default:
+      return (PCMDMX_UNKNOWN_PARAM);
+  }
+
+  return (PCMDMX_OK);
+}
+
+/*
+ * Read DMX meta-data from a data stream element.
+ */
+PCMDMX_ERROR pcmDmx_Parse(HANDLE_PCM_DOWNMIX self, HANDLE_FDK_BITSTREAM hBs,
+                          UINT ancDataBits, int isMpeg2) {
+  PCMDMX_ERROR errorStatus = PCMDMX_OK;
+
+#define MAX_DSE_ANC_BYTES (16)    /* 15 bytes */
+#define ANC_DATA_SYNC_BYTE (0xBC) /* ancillary data sync byte. */
+
+  DMX_BS_META_DATA *pBsMetaData;
+
+  int skip4Dmx = 0, skip4Ext = 0;
+  int dmxLvlAvail = 0, extDataAvail = 0;
+  UINT foundNewData = 0;
+  UINT minAncBits = ((isMpeg2) ? 5 : 3) * 8;
+
+  if ((self == NULL) || (hBs == NULL)) {
+    return (PCMDMX_INVALID_HANDLE);
+  }
+
+  /* sanity checks */
+  if ((ancDataBits < minAncBits) || (ancDataBits > FDKgetValidBits(hBs))) {
+    return (PCMDMX_CORRUPT_ANC_DATA);
+  }
+
+  pBsMetaData = &self->bsMetaData[0];
+
+  if (isMpeg2) {
+    /* skip DVD ancillary data */
+    FDKpushFor(hBs, 16);
+  }
+
+  /* check sync word */
+  if (FDKreadBits(hBs, 8) != ANC_DATA_SYNC_BYTE) {
+    return (PCMDMX_CORRUPT_ANC_DATA);
+  }
+
+  /* skip MPEG audio type and Dolby surround mode */
+  FDKpushFor(hBs, 4);
+
+  if (isMpeg2) {
+    /* int numAncBytes = */ FDKreadBits(hBs, 4);
+    /* advanced dynamic range control */
+    if (FDKreadBit(hBs)) skip4Dmx += 24;
+    /* dialog normalization */
+    if (FDKreadBit(hBs)) skip4Dmx += 8;
+    /* reproduction_level */
+    if (FDKreadBit(hBs)) skip4Dmx += 8;
+  } else {
+    FDKpushFor(hBs, 2); /* drc presentation mode */
+    pBsMetaData->pseudoSurround = (SCHAR)FDKreadBit(hBs);
+    FDKpushFor(hBs, 4); /* reserved bits */
+  }
+
+  /* downmixing levels MPEGx status */
+  dmxLvlAvail = FDKreadBit(hBs);
+
+  if (isMpeg2) {
+    /* scale factor CRC status */
+    if (FDKreadBit(hBs)) skip4Ext += 16;
+  } else {
+    /* ancillary data extension status */
+    extDataAvail = FDKreadBit(hBs);
+  }
+
+  /* audio coding and compression status */
+  if (FDKreadBit(hBs)) skip4Ext += 16;
+  /* coarse grain timecode status */
+  if (FDKreadBit(hBs)) skip4Ext += 16;
+  /* fine grain timecode status */
+  if (FDKreadBit(hBs)) skip4Ext += 16;
+
+  /* skip the useless data to get to the DMX levels */
+  FDKpushFor(hBs, skip4Dmx);
+
+  /* downmix_levels_MPEGX */
+  if (dmxLvlAvail) {
+    if (FDKreadBit(hBs)) { /* center_mix_level_on */
+      pBsMetaData->cLevIdx = (UCHAR)FDKreadBits(hBs, 3);
+      foundNewData |= TYPE_DSE_CLEV_DATA;
+    } else {
+      FDKreadBits(hBs, 3);
+    }
+    if (FDKreadBit(hBs)) { /* surround_mix_level_on */
+      pBsMetaData->sLevIdx = (UCHAR)FDKreadBits(hBs, 3);
+      foundNewData |= TYPE_DSE_SLEV_DATA;
+    } else {
+      FDKreadBits(hBs, 3);
+    }
+  }
+
+  /* skip the useless data to get to the ancillary data extension */
+  FDKpushFor(hBs, skip4Ext);
+
+  /* anc data extension (MPEG-4 only) */
+  if (extDataAvail) {
+    int extDmxLvlSt, extDmxGainSt, extDmxLfeSt;
+
+    FDKreadBit(hBs); /* reserved bit */
+    extDmxLvlSt = FDKreadBit(hBs);
+    extDmxGainSt = FDKreadBit(hBs);
+    extDmxLfeSt = FDKreadBit(hBs);
+    FDKreadBits(hBs, 4); /* reserved bits */
+
+    if (extDmxLvlSt) {
+      pBsMetaData->dmixIdxA = (UCHAR)FDKreadBits(hBs, 3);
+      pBsMetaData->dmixIdxB = (UCHAR)FDKreadBits(hBs, 3);
+      FDKreadBits(hBs, 2); /* reserved bits */
+      foundNewData |= TYPE_DSE_DMIX_AB_DATA;
+    }
+    if (extDmxGainSt) {
+      pBsMetaData->dmxGainIdx5 = (UCHAR)FDKreadBits(hBs, 7);
+      FDKreadBit(hBs); /* reserved bit */
+      pBsMetaData->dmxGainIdx2 = (UCHAR)FDKreadBits(hBs, 7);
+      FDKreadBit(hBs); /* reserved bit */
+      foundNewData |= TYPE_DSE_DMX_GAIN_DATA;
+    }
+    if (extDmxLfeSt) {
+      pBsMetaData->dmixIdxLfe = (UCHAR)FDKreadBits(hBs, 4);
+      FDKreadBits(hBs, 4); /* reserved bits */
+      foundNewData |= TYPE_DSE_DMIX_LFE_DATA;
+    }
+  }
+
+  /* final sanity check on the amount of read data */
+  if ((INT)FDKgetValidBits(hBs) < 0) {
+    errorStatus = PCMDMX_CORRUPT_ANC_DATA;
+  }
+
+  if ((errorStatus == PCMDMX_OK) && (foundNewData != 0)) {
+    /* announce new data */
+    pBsMetaData->typeFlags |= foundNewData;
+    /* reset expiry counter */
+    pBsMetaData->expiryCount = 0;
+  }
+
+  return (errorStatus);
+}
+
+/*
+ * Read DMX meta-data from a data stream element.
+ */
+PCMDMX_ERROR pcmDmx_ReadDvbAncData(HANDLE_PCM_DOWNMIX self, UCHAR *pAncDataBuf,
+                                   UINT ancDataBytes, int isMpeg2) {
+  PCMDMX_ERROR errorStatus = PCMDMX_OK;
+  FDK_BITSTREAM bs;
+  HANDLE_FDK_BITSTREAM hBs = &bs;
+
+  if (self == NULL) {
+    return (PCMDMX_INVALID_HANDLE);
+  }
+
+  /* sanity checks */
+  if ((pAncDataBuf == NULL) || (ancDataBytes == 0)) {
+    return (PCMDMX_CORRUPT_ANC_DATA);
+  }
+
+  FDKinitBitStream(hBs, pAncDataBuf, MAX_DSE_ANC_BYTES, ancDataBytes * 8,
+                   BS_READER);
+
+  errorStatus = pcmDmx_Parse(self, hBs, ancDataBytes * 8, isMpeg2);
+
+  return (errorStatus);
+}
+
+/** Set the matrix mixdown information extracted from the PCE of an AAC
+ *bitstream. Note: Call only if matrix_mixdown_idx_present is true.
+ * @param [in] Handle of PCM downmix module instance.
+ * @param [in] The 2 bit matrix mixdown index extracted from PCE.
+ * @param [in] The pseudo surround enable flag extracted from PCE.
+ * @returns Returns an error code.
+ **/
+PCMDMX_ERROR pcmDmx_SetMatrixMixdownFromPce(HANDLE_PCM_DOWNMIX self,
+                                            int matrixMixdownPresent,
+                                            int matrixMixdownIdx,
+                                            int pseudoSurroundEnable) {
+  if (self == NULL) {
+    return (PCMDMX_INVALID_HANDLE);
+  }
+
+  {
+    DMX_BS_META_DATA *pBsMetaData = &self->bsMetaData[0];
+
+    if (matrixMixdownPresent) {
+      pBsMetaData->pseudoSurround = (pseudoSurroundEnable) ? 1 : 0;
+      pBsMetaData->matrixMixdownIdx = matrixMixdownIdx & 0x03;
+      pBsMetaData->typeFlags |= TYPE_PCE_DATA;
+      /* Reset expiry counter */
+      pBsMetaData->expiryCount = 0;
+    }
+  }
+
+  return (PCMDMX_OK);
+}
+
+/** Apply down or up mixing.
+ * @param [in]    Handle of PCM downmix module instance.
+ * @param [inout] Pointer to buffer that hold the time domain signal.
+ * @param [in]    Pointer where the amount of output samples is returned into.
+ * @param [in]    Size of pPcmBuf.
+ * @param [inout] Pointer where the amount of output channels is returned into.
+ * @param [in]    Input and output samples are processed interleaved.
+ * @param [inout] Array where the corresponding channel type for each output
+ *audio channel is stored into.
+ * @param [inout] Array where the corresponding channel type index for each
+ *output audio channel is stored into.
+ * @param [in]    Array containing the out channel mapping to be used (From MPEG
+ *PCE ordering to whatever is required).
+ * @param [out]   Pointer on a field receiving the scale factor that has to be
+ *applied on all samples afterwards. If the handed pointer is NULL scaling is
+ *done internally.
+ * @returns Returns an error code.
+ **/
+PCMDMX_ERROR pcmDmx_ApplyFrame(HANDLE_PCM_DOWNMIX self, DMX_PCM *pPcmBuf,
+                               const int pcmBufSize, UINT frameSize,
+                               INT *nChannels, INT fInterleaved,
+                               AUDIO_CHANNEL_TYPE channelType[],
+                               UCHAR channelIndices[],
+                               const FDK_channelMapDescr *const mapDescr,
+                               INT *pDmxOutScale) {
+  PCM_DMX_USER_PARAMS *pParam = NULL;
+  PCMDMX_ERROR errorStatus = PCMDMX_OK;
+  DUAL_CHANNEL_MODE dualChannelMode;
+  PCM_DMX_CHANNEL_MODE inChMode;
+  PCM_DMX_CHANNEL_MODE outChMode;
+  INT devNull; /* Just a dummy to avoid a lot of branches in the code */
+  int numOutChannels, numInChannels;
+  int inStride, outStride, offset;
+  int dmxMaxScale, dmxScale;
+  int slot;
+  UCHAR inOffsetTable[(8)];
+
+  DMX_BS_META_DATA bsMetaData;
+
+  if ((self == NULL) || (nChannels == NULL) || (channelType == NULL) ||
+      (channelIndices == NULL) || (!FDK_chMapDescr_isValid(mapDescr))) {
+    return (PCMDMX_INVALID_HANDLE);
+  }
+
+  /* Init the output scaling */
+  dmxScale = 0;
+  if (pDmxOutScale != NULL) {
+    /* Avoid final scaling internally and hand it to the outside world. */
+    *pDmxOutScale = 0;
+    dmxMaxScale = (3);
+  } else {
+    /* Apply the scaling internally. */
+    pDmxOutScale = &devNull; /* redirect to temporal stack memory */
+    dmxMaxScale = 0;
+  }
+
+  pParam = &self->userParams;
+  numInChannels = *nChannels;
+
+  /* Perform some input sanity checks */
+  if (pPcmBuf == NULL) {
+    return (PCMDMX_INVALID_ARGUMENT);
+  }
+  if (frameSize == 0) {
+    return (PCMDMX_INVALID_ARGUMENT);
+  }
+  if (numInChannels == 0) {
+    return (PCMDMX_INVALID_ARGUMENT);
+  }
+  if (numInChannels > (8)) {
+    return (PCMDMX_INVALID_CH_CONFIG);
+  }
+
+  /* Check on misconfiguration */
+  FDK_ASSERT((pParam->numOutChannelsMax <= 0) ||
+             (pParam->numOutChannelsMax >= pParam->numOutChannelsMin));
+
+  /* Determine if the module has to do processing */
+  if ((self->applyProcessing == 0) &&
+      ((pParam->numOutChannelsMax <= 0) ||
+       (pParam->numOutChannelsMax >= numInChannels)) &&
+      (pParam->numOutChannelsMin <= numInChannels)) {
+    /* Nothing to do */
+    return (errorStatus);
+  }
+
+  /* Determine the number of output channels */
+  if ((pParam->numOutChannelsMax > 0) &&
+      (numInChannels > pParam->numOutChannelsMax)) {
+    numOutChannels = pParam->numOutChannelsMax;
+  } else if (numInChannels < pParam->numOutChannelsMin) {
+    numOutChannels = pParam->numOutChannelsMin;
+  } else {
+    numOutChannels = numInChannels;
+  }
+
+  /* Check I/O buffer size */
+  if ((UINT)pcmBufSize < (UINT)numOutChannels * frameSize) {
+    return (PCMDMX_OUTPUT_BUFFER_TOO_SMALL);
+  }
+
+  dualChannelMode = pParam->dualChannelMode;
+
+  /* Analyse input channel configuration and get channel offset
+   * table that can be accessed with the fixed channel labels. */
+  errorStatus = getChannelMode(numInChannels, channelType, channelIndices,
+                               inOffsetTable, &inChMode);
+  if (PCMDMX_IS_FATAL_ERROR(errorStatus) || (inChMode == CH_MODE_UNDEFINED)) {
+    /* We don't need to restore because the channel
+       configuration has not been changed. Just exit. */
+    return (PCMDMX_INVALID_CH_CONFIG);
+  }
+
+  /* Set input stride and offset */
+  if (fInterleaved) {
+    inStride = numInChannels;
+    offset = 1; /* Channel specific offset factor */
+  } else {
+    inStride = 1;
+    offset = frameSize; /* Channel specific offset factor */
+  }
+
+  /* Reset downmix meta data if necessary */
+  if ((pParam->expiryFrame > 0) &&
+      (++self->bsMetaData[0].expiryCount >
+       pParam
+           ->expiryFrame)) { /* The metadata read from bitstream is too old. */
+#ifdef FDK_ASSERT_ENABLE
+    PCMDMX_ERROR err = pcmDmx_Reset(self, PCMDMX_RESET_BS_DATA);
+    FDK_ASSERT(err == PCMDMX_OK);
+#else
+    pcmDmx_Reset(self, PCMDMX_RESET_BS_DATA);
+#endif
+  }
+  FDKmemcpy(&bsMetaData, &self->bsMetaData[pParam->frameDelay],
+            sizeof(DMX_BS_META_DATA));
+  /* Maintain delay line */
+  for (slot = pParam->frameDelay; slot > 0; slot -= 1) {
+    FDKmemcpy(&self->bsMetaData[slot], &self->bsMetaData[slot - 1],
+              sizeof(DMX_BS_META_DATA));
+  }
+
+  /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   * - - - - - - - - - - - - - - - - - - */
+  if (numInChannels > numOutChannels) { /* Apply downmix */
+    DMX_PCM *pInPcm[(8)] = {NULL};
+    DMX_PCM *pOutPcm[(8)] = {NULL};
+    FIXP_DMX mixFactors[(8)][(8)];
+    UCHAR outOffsetTable[(8)];
+    UINT sample;
+    int chCfg = 0;
+    int bypScale = 0;
+
+    if (numInChannels > SIX_CHANNEL) {
+      AUDIO_CHANNEL_TYPE multiPurposeChType[2];
+
+      /* Get the type of the multipurpose channels */
+      multiPurposeChType[0] =
+          channelType[inOffsetTable[LEFT_MULTIPRPS_CHANNEL]];
+      multiPurposeChType[1] =
+          channelType[inOffsetTable[RIGHT_MULTIPRPS_CHANNEL]];
+
+      /* Check if the input configuration is one defined in the standard. */
+      switch (inChMode) {
+        case CH_MODE_5_0_2_1: /* chCfg 7 || 14 */
+          /* Further analyse the input config to distinguish the two
+           * CH_MODE_5_0_2_1 configs. */
+          if ((multiPurposeChType[0] == ACT_FRONT_TOP) &&
+              (multiPurposeChType[1] == ACT_FRONT_TOP)) {
+            chCfg = 14;
+          } else {
+            chCfg = 7;
+          }
+          break;
+        case CH_MODE_3_0_3_1: /* chCfg 11 */
+          chCfg = 11;
+          break;
+        case CH_MODE_3_0_4_1: /* chCfg 12 */
+          chCfg = 12;
+          break;
+        default:
+          chCfg = 0; /* Not a known config */
+          break;
+      }
+    }
+
+    /* Set this stages output stride and channel mode: */
+    outStride = (fInterleaved) ? numOutChannels : 1;
+    outChMode = outChModeTable[numOutChannels];
+    FDK_ASSERT(outChMode != CH_MODE_UNDEFINED);
+
+    /* Get channel description and channel mapping for the desired output
+     * configuration. */
+    getChannelDescription(outChMode, mapDescr, channelType, channelIndices,
+                          outOffsetTable);
+    /* Now there is no way back because we modified the channel configuration!
+     */
+
+    /* Create the DMX matrix */
+    errorStatus =
+        getMixFactors((chCfg > 0) ? 1 : 0,
+                      (chCfg > 0) ? (PCM_DMX_CHANNEL_MODE)chCfg : inChMode,
+                      outChMode, pParam, &bsMetaData, mixFactors, &dmxScale);
+    /* No fatal errors can occur here. The function is designed to always return
+       a valid matrix. The error code is used to signal configurations and
+       matrices that are not conform to any standard. */
+
+    /* Determine the final scaling */
+    bypScale = fMin(dmxMaxScale, dmxScale);
+    *pDmxOutScale += bypScale;
+    dmxScale -= bypScale;
+
+    { /* Set channel pointer for input. Remove empty cols. */
+      int inCh, outCh, map[(8)];
+      int ch = 0;
+      for (inCh = 0; inCh < (8); inCh += 1) {
+        if (inOffsetTable[inCh] < (UCHAR)numInChannels) {
+          pInPcm[ch] = &pPcmBuf[inOffsetTable[inCh] * offset];
+          map[ch++] = inCh;
+        }
+      }
+      for (; ch < (8); ch += 1) {
+        map[ch] = ch;
+      }
+
+      /* Remove unused cols from factor matrix */
+      for (inCh = 0; inCh < numInChannels; inCh += 1) {
+        if (inCh != map[inCh]) {
+          for (outCh = 0; outCh < (8); outCh += 1) {
+            mixFactors[outCh][inCh] = mixFactors[outCh][map[inCh]];
+          }
+        }
+      }
+
+      /* Set channel pointer for output. Remove empty cols. */
+      ch = 0;
+      for (outCh = 0; outCh < (8); outCh += 1) {
+        if (outOffsetTable[outCh] < (UCHAR)numOutChannels) {
+          pOutPcm[ch] = &pPcmBuf[outOffsetTable[outCh] * offset];
+          map[ch++] = outCh;
+        }
+      }
+      for (; ch < (8); ch += 1) {
+        map[ch] = ch;
+      }
+
+      /* Remove unused rows from factor matrix */
+      for (outCh = 0; outCh < numOutChannels; outCh += 1) {
+        if (outCh != map[outCh]) {
+          FDKmemcpy(&mixFactors[outCh], &mixFactors[map[outCh]],
+                    (8) * sizeof(FIXP_DMX));
+        }
+      }
+    }
+
+    /* Sample processing loop */
+    for (sample = 0; sample < frameSize; sample++) {
+      DMX_PCM tIn[(8)] = {0};
+      FIXP_DBL tOut[(8)] = {(FIXP_DBL)0};
+      int inCh, outCh;
+
+      /* Preload all input samples */
+      for (inCh = 0; inCh < numInChannels; inCh += 1) {
+        if (pInPcm[inCh] != NULL) {
+          tIn[inCh] = *pInPcm[inCh];
+          pInPcm[inCh] += inStride;
+        } else {
+          tIn[inCh] = (DMX_PCM)0;
+        }
+      }
+      /* Apply downmix coefficients to input samples and accumulate for output
+       */
+      for (outCh = 0; outCh < numOutChannels; outCh += 1) {
+        for (inCh = 0; inCh < numInChannels; inCh += 1) {
+          tOut[outCh] += fMult((DMX_PCMF)tIn[inCh], mixFactors[outCh][inCh]);
+        }
+        FDK_ASSERT(pOutPcm[outCh] >= pPcmBuf);
+        FDK_ASSERT(pOutPcm[outCh] < &pPcmBuf[pcmBufSize]);
+        /* Write sample */
+        *pOutPcm[outCh] = (DMX_PCM)SATURATE_SHIFT(
+            tOut[outCh], DFRACT_BITS - DMX_PCM_BITS - dmxScale, DMX_PCM_BITS);
+        pOutPcm[outCh] += outStride;
+      }
+    }
+
+    /* Update the number of output channels */
+    *nChannels = numOutChannels;
+
+  } /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+       - - - - - - - - - - - - - - - - - - */
+  else if (numInChannels < numOutChannels) { /* Apply rudimentary upmix */
+    /* Set up channel pointer */
+    UCHAR outOffsetTable[(8)];
+
+    /* FIRST STAGE
+         Create a stereo/dual channel signal */
+    if (numInChannels == ONE_CHANNEL) {
+      DMX_PCM *pInPcm[(8)];
+      DMX_PCM *pOutLF, *pOutRF;
+      UINT sample;
+
+      /* Set this stages output stride and channel mode: */
+      outStride = (fInterleaved) ? TWO_CHANNEL : 1;
+      outChMode = outChModeTable[TWO_CHANNEL];
+
+      /* Get channel description and channel mapping for this
+       * stages number of output channels (always STEREO). */
+      getChannelDescription(outChMode, mapDescr, channelType, channelIndices,
+                            outOffsetTable);
+      /* Now there is no way back because we modified the channel configuration!
+       */
+
+      /* Set input channel pointer. The first channel is always at index 0. */
+      pInPcm[CENTER_FRONT_CHANNEL] =
+          &pPcmBuf[(frameSize - 1) *
+                   inStride]; /* Considering input mapping could lead to a
+                                 invalid pointer here if the channel is not
+                                 declared to be a front channel. */
+
+      /* Set output channel pointer (for this stage). */
+      pOutLF = &pPcmBuf[outOffsetTable[LEFT_FRONT_CHANNEL] * offset +
+                        (frameSize - 1) * outStride];
+      pOutRF = &pPcmBuf[outOffsetTable[RIGHT_FRONT_CHANNEL] * offset +
+                        (frameSize - 1) * outStride];
+
+      /* 1/0 input: */
+      for (sample = 0; sample < frameSize; sample++) {
+        /* L' = C;  R' = C; */
+        *pOutLF = *pOutRF = *pInPcm[CENTER_FRONT_CHANNEL];
+
+        pInPcm[CENTER_FRONT_CHANNEL] -= inStride;
+        pOutLF -= outStride;
+        pOutRF -= outStride;
+      }
+
+      /* Prepare for next stage: */
+      inStride = outStride;
+      inChMode = outChMode;
+      FDKmemcpy(inOffsetTable, outOffsetTable, (8) * sizeof(UCHAR));
+    }
+
+    /* SECOND STAGE
+         Extend with zero channels to achieved the desired number of output
+       channels. */
+    if (numOutChannels > TWO_CHANNEL) {
+      DMX_PCM *pIn[(8)] = {NULL};
+      DMX_PCM *pOut[(8)] = {NULL};
+      UINT sample;
+      AUDIO_CHANNEL_TYPE inChTypes[(8)];
+      UCHAR inChIndices[(8)];
+      UCHAR numChPerGrp[2][(4)];
+      int nContentCh = 0; /* Number of channels with content */
+      int nEmptyCh = 0;   /* Number of channels with content */
+      int ch, chGrp, isCompatible = 1;
+
+      /* Do not change the signalling which is the channel types and indices.
+         Just reorder and add channels. So first save the input signalling. */
+      FDKmemcpy(inChTypes, channelType,
+                numInChannels * sizeof(AUDIO_CHANNEL_TYPE));
+      FDKmemclear(inChTypes + numInChannels,
+                  ((8) - numInChannels) * sizeof(AUDIO_CHANNEL_TYPE));
+      FDKmemcpy(inChIndices, channelIndices, numInChannels * sizeof(UCHAR));
+      FDKmemclear(inChIndices + numInChannels,
+                  ((8) - numInChannels) * sizeof(UCHAR));
+
+      /* Set this stages output stride and channel mode: */
+      outStride = (fInterleaved) ? numOutChannels : 1;
+      outChMode = outChModeTable[numOutChannels];
+      FDK_ASSERT(outChMode != CH_MODE_UNDEFINED);
+
+      /* Check if input channel config can be easily mapped to the desired
+       * output config. */
+      for (chGrp = 0; chGrp < (4); chGrp += 1) {
+        numChPerGrp[IN][chGrp] = (inChMode >> (chGrp * 4)) & 0xF;
+        numChPerGrp[OUT][chGrp] = (outChMode >> (chGrp * 4)) & 0xF;
+
+        if (numChPerGrp[IN][chGrp] > numChPerGrp[OUT][chGrp]) {
+          isCompatible = 0;
+          break;
+        }
+      }
+
+      if (isCompatible) {
+        /* Get new channel description and channel
+         * mapping for the desired output channel mode. */
+        getChannelDescription(outChMode, mapDescr, channelType, channelIndices,
+                              outOffsetTable);
+        /* If the input config has a back center channel but the output
+           config has not, copy it to left and right (if available). */
+        if ((numChPerGrp[IN][CH_GROUP_REAR] % 2) &&
+            !(numChPerGrp[OUT][CH_GROUP_REAR] % 2)) {
+          if (numChPerGrp[IN][CH_GROUP_REAR] == 1) {
+            inOffsetTable[RIGHT_REAR_CHANNEL] =
+                inOffsetTable[LEFT_REAR_CHANNEL];
+          } else if (numChPerGrp[IN][CH_GROUP_REAR] == 3) {
+            inOffsetTable[RIGHT_MULTIPRPS_CHANNEL] =
+                inOffsetTable[LEFT_MULTIPRPS_CHANNEL];
+          }
+        }
+      } else {
+        /* Just copy and extend the original config */
+        FDKmemcpy(outOffsetTable, inOffsetTable, (8) * sizeof(UCHAR));
+      }
+
+      /* Set I/O channel pointer.
+         Note: The following assignment algorithm clears the channel offset
+         tables. Thus they can not be used afterwards. */
+      for (ch = 0; ch < (8); ch += 1) {
+        if ((outOffsetTable[ch] < 255) &&
+            (inOffsetTable[ch] < 255)) { /* Set I/O pointer: */
+          pIn[nContentCh] =
+              &pPcmBuf[inOffsetTable[ch] * offset + (frameSize - 1) * inStride];
+          pOut[nContentCh] = &pPcmBuf[outOffsetTable[ch] * offset +
+                                      (frameSize - 1) * outStride];
+          /* Update signalling */
+          channelType[outOffsetTable[ch]] = inChTypes[inOffsetTable[ch]];
+          channelIndices[outOffsetTable[ch]] = inChIndices[inOffsetTable[ch]];
+          inOffsetTable[ch] = 255;
+          outOffsetTable[ch] = 255;
+          nContentCh += 1;
+        }
+      }
+      if (isCompatible) {
+        /* Assign the remaining input channels.
+           This is just a safety appliance. We should never need it. */
+        for (ch = 0; ch < (8); ch += 1) {
+          if (inOffsetTable[ch] < 255) {
+            int outCh;
+            for (outCh = 0; outCh < (8); outCh += 1) {
+              if (outOffsetTable[outCh] < 255) {
+                break;
+              }
+            }
+            if (outCh >= (8)) {
+              FDK_ASSERT(0);
+              break;
+            }
+            /* Set I/O pointer: */
+            pIn[nContentCh] = &pPcmBuf[inOffsetTable[ch] * offset +
+                                       (frameSize - 1) * inStride];
+            pOut[nContentCh] = &pPcmBuf[outOffsetTable[outCh] * offset +
+                                        (frameSize - 1) * outStride];
+            /* Update signalling */
+            FDK_ASSERT(inOffsetTable[outCh] < numInChannels);
+            FDK_ASSERT(outOffsetTable[outCh] < numOutChannels);
+            channelType[outOffsetTable[outCh]] = inChTypes[inOffsetTable[ch]];
+            channelIndices[outOffsetTable[outCh]] =
+                inChIndices[inOffsetTable[ch]];
+            inOffsetTable[ch] = 255;
+            outOffsetTable[outCh] = 255;
+            nContentCh += 1;
+          }
+        }
+        /* Set the remaining output channel pointer */
+        for (ch = 0; ch < (8); ch += 1) {
+          if (outOffsetTable[ch] < 255) {
+            pOut[nContentCh + nEmptyCh] = &pPcmBuf[outOffsetTable[ch] * offset +
+                                                   (frameSize - 1) * outStride];
+            /* Expand output signalling */
+            channelType[outOffsetTable[ch]] = ACT_NONE;
+            channelIndices[outOffsetTable[ch]] = (UCHAR)nEmptyCh;
+            outOffsetTable[ch] = 255;
+            nEmptyCh += 1;
+          }
+        }
+      } else {
+        /* Set the remaining output channel pointer */
+        for (ch = nContentCh; ch < numOutChannels; ch += 1) {
+          pOut[ch] = &pPcmBuf[ch * offset + (frameSize - 1) * outStride];
+          /* Expand output signalling */
+          channelType[ch] = ACT_NONE;
+          channelIndices[ch] = (UCHAR)nEmptyCh;
+          nEmptyCh += 1;
+        }
+      }
+
+      /* First copy the channels that have signal */
+      for (sample = 0; sample < frameSize; sample += 1) {
+        DMX_PCM tIn[(8)];
+        /* Read all channel samples */
+        for (ch = 0; ch < nContentCh; ch += 1) {
+          tIn[ch] = *pIn[ch];
+          pIn[ch] -= inStride;
+        }
+        /* Write all channel samples */
+        for (ch = 0; ch < nContentCh; ch += 1) {
+          *pOut[ch] = tIn[ch];
+          pOut[ch] -= outStride;
+        }
+      }
+
+      /* Clear all the other channels */
+      for (sample = 0; sample < frameSize; sample++) {
+        for (ch = nContentCh; ch < numOutChannels; ch += 1) {
+          *pOut[ch] = (DMX_PCM)0;
+          pOut[ch] -= outStride;
+        }
+      }
+    }
+
+    /* update the number of output channels */
+    *nChannels = numOutChannels;
+  } /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+       - - - - - - - - - - - - - - - - - - */
+  else if (numInChannels == numOutChannels) {
+    /* Don't need to change the channel description here */
+
+    switch (numInChannels) {
+      case 2: { /* Set up channel pointer */
+        DMX_PCM *pInPcm[(8)];
+        DMX_PCM *pOutL, *pOutR;
+        FIXP_DMX flev;
+
+        UINT sample;
+
+        if (fInterleaved) {
+          inStride = numInChannels;
+          outStride =
+              2; /* fixed !!! (below stereo is donwmixed to mono if required */
+          offset = 1; /* Channel specific offset factor */
+        } else {
+          inStride = 1;
+          outStride = 1;
+          offset = frameSize; /* Channel specific offset factor */
+        }
+
+        /* Set input channel pointer */
+        pInPcm[LEFT_FRONT_CHANNEL] =
+            &pPcmBuf[inOffsetTable[LEFT_FRONT_CHANNEL] * offset];
+        pInPcm[RIGHT_FRONT_CHANNEL] =
+            &pPcmBuf[inOffsetTable[RIGHT_FRONT_CHANNEL] * offset];
+
+        /* Set output channel pointer (same as input) */
+        pOutL = pInPcm[LEFT_FRONT_CHANNEL];
+        pOutR = pInPcm[RIGHT_FRONT_CHANNEL];
+
+        /* Set downmix levels: */
+        flev = FL2FXCONST_DMX(0.70710678f);
+        /* 2/0 input: */
+        switch (dualChannelMode) {
+          case CH1_MODE: /* L' = 0.707 * Ch1;  R' = 0.707 * Ch1 */
+            for (sample = 0; sample < frameSize; sample++) {
+              *pOutL = *pOutR = (DMX_PCM)SATURATE_RIGHT_SHIFT(
+                  fMult((DMX_PCMF)*pInPcm[LEFT_FRONT_CHANNEL], flev),
+                  DFRACT_BITS - DMX_PCM_BITS, DMX_PCM_BITS);
+
+              pInPcm[LEFT_FRONT_CHANNEL] += inStride;
+              pOutL += outStride;
+              pOutR += outStride;
+            }
+            break;
+          case CH2_MODE: /* L' = 0.707 * Ch2;  R' = 0.707 * Ch2 */
+            for (sample = 0; sample < frameSize; sample++) {
+              *pOutL = *pOutR = (DMX_PCM)SATURATE_RIGHT_SHIFT(
+                  fMult((DMX_PCMF)*pInPcm[RIGHT_FRONT_CHANNEL], flev),
+                  DFRACT_BITS - DMX_PCM_BITS, DMX_PCM_BITS);
+
+              pInPcm[RIGHT_FRONT_CHANNEL] += inStride;
+              pOutL += outStride;
+              pOutR += outStride;
+            }
+            break;
+          case MIXED_MODE: /* L' = 0.5*Ch1 + 0.5*Ch2;  R' = 0.5*Ch1 + 0.5*Ch2 */
+            for (sample = 0; sample < frameSize; sample++) {
+              *pOutL = *pOutR = (*pInPcm[LEFT_FRONT_CHANNEL] >> 1) +
+                                (*pInPcm[RIGHT_FRONT_CHANNEL] >> 1);
+
+              pInPcm[LEFT_FRONT_CHANNEL] += inStride;
+              pInPcm[RIGHT_FRONT_CHANNEL] += inStride;
+              pOutL += outStride;
+              pOutR += outStride;
+            }
+            break;
+          default:
+          case STEREO_MODE:
+            /* nothing to do */
+            break;
+        }
+      } break;
+
+      default:
+        /* nothing to do */
+        break;
+    }
+  }
+
+  return (errorStatus);
+}
+
+/** Close an instance of the PCM downmix module.
+ * @param [inout] Pointer to a buffer containing the handle of the instance.
+ * @returns Returns an error code.
+ **/
+PCMDMX_ERROR pcmDmx_Close(HANDLE_PCM_DOWNMIX *pSelf) {
+  if (pSelf == NULL) {
+    return (PCMDMX_INVALID_HANDLE);
+  }
+
+  FreePcmDmxInstance(pSelf);
+  *pSelf = NULL;
+
+  return (PCMDMX_OK);
+}
+
+/** Get library info for this module.
+ * @param [out] Pointer to an allocated LIB_INFO structure.
+ * @returns Returns an error code.
+ */
+PCMDMX_ERROR pcmDmx_GetLibInfo(LIB_INFO *info) {
+  int i;
+
+  if (info == NULL) {
+    return PCMDMX_INVALID_ARGUMENT;
+  }
+
+  /* Search for next free tab */
+  for (i = 0; i < FDK_MODULE_LAST; i++) {
+    if (info[i].module_id == FDK_NONE) break;
+  }
+  if (i == FDK_MODULE_LAST) {
+    return PCMDMX_INVALID_ARGUMENT;
+  }
+
+  /* Add the library info */
+  info[i].module_id = FDK_PCMDMX;
+  info[i].version =
+      LIB_VERSION(PCMUTIL_LIB_VL0, PCMUTIL_LIB_VL1, PCMUTIL_LIB_VL2);
+  LIB_VERSION_STRING(info + i);
+  info[i].build_date = PCMUTIL_LIB_BUILD_DATE;
+  info[i].build_time = PCMUTIL_LIB_BUILD_TIME;
+  info[i].title = PCMDMX_LIB_TITLE;
+
+  /* Set flags */
+  info[i].flags = 0 | CAPF_DMX_BLIND /* At least blind downmixing is possible */
+                  | CAPF_DMX_PCE     /* Guided downmix with data from MPEG-2/4
+                                        Program Config Elements (PCE). */
+                  | CAPF_DMX_ARIB /* PCE guided downmix with slightly different
+                                     equations and levels. */
+                  | CAPF_DMX_DVB  /* Guided downmix with data from DVB ancillary
+                                     data fields. */
+                  | CAPF_DMX_CH_EXP /* Simple upmixing by dublicating channels
+                                       or adding zero channels. */
+                  | CAPF_DMX_6_CH | CAPF_DMX_8_CH;
+
+  /* Add lib info for FDK tools (if not yet done). */
+  FDK_toolsGetLibInfo(info);
+
+  return PCMDMX_OK;
+}
diff --git a/fdk-aac/libPCMutils/src/version.h b/fdk-aac/libPCMutils/src/version.h
new file mode 100644
index 0000000..fa31af1
--- /dev/null
+++ b/fdk-aac/libPCMutils/src/version.h
@@ -0,0 +1,119 @@
+/* -----------------------------------------------------------------------------
+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
+----------------------------------------------------------------------------- */
+
+/**************************** PCM utility library ******************************
+
+   Author(s):
+
+   Description:
+
+*******************************************************************************/
+
+#if !defined(VERSION_H)
+#define VERSION_H
+
+/* library info */
+#define PCMUTIL_LIB_VL0 3
+#define PCMUTIL_LIB_VL1 0
+#define PCMUTIL_LIB_VL2 0
+#define PCMUTIL_LIB_TITLE "PCM Utility Lib"
+#ifdef __ANDROID__
+#define PCMUTIL_LIB_BUILD_DATE ""
+#define PCMUTIL_LIB_BUILD_TIME ""
+#else
+#define PCMUTIL_LIB_BUILD_DATE __DATE__
+#define PCMUTIL_LIB_BUILD_TIME __TIME__
+#endif
+
+#endif /* !defined(VERSION_H) */