Fraunhofer AAC codec.

License boilerplate update to follow.

Change-Id: I2810460c11a58b6d148d84673cc031f3685e79b5

2 files changed, 1235 insertions, 0 deletions

diff --git a/libPCMutils/src/Android.mk b/libPCMutils/src/Android.mk
new file mode 100644
index 0000000..174581c
--- /dev/null
+++ b/libPCMutils/src/Android.mk
@@ -0,0 +1,16 @@
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := pcmutils_lib.cpp
+
+LOCAL_CFLAGS := -DANDROID
+
+LOCAL_C_INCLUDES += \
+        $(LOCAL_PATH) \
+        $(LOCAL_PATH)/../include \
+        $(LOCAL_PATH)/../../libSYS/include \
+        $(LOCAL_PATH)/../../libFDK/include
+
+LOCAL_MODULE:= libPCMutils
+
+include $(BUILD_STATIC_LIBRARY)
diff --git a/libPCMutils/src/pcmutils_lib.cpp b/libPCMutils/src/pcmutils_lib.cpp
new file mode 100644
index 0000000..1beec6a
--- /dev/null
+++ b/libPCMutils/src/pcmutils_lib.cpp
@@ -0,0 +1,1219 @@
+/****************************  FDK PCM utils module  **************************
+
+                        (C) Copyright Fraunhofer IIS 2008
+                               All Rights Reserved
+
+    Please be advised that this software and/or program delivery is
+    Confidential Information of Fraunhofer and subject to and covered by the
+
+    Fraunhofer IIS Software Evaluation Agreement
+    between Google Inc. and  Fraunhofer
+    effective and in full force since March 1, 2012.
+
+    You may use this software and/or program only under the terms and
+    conditions described in the above mentioned Fraunhofer IIS Software
+    Evaluation Agreement. Any other and/or further use requires a separate agreement.
+
+
+   $Id$
+   Author(s):   Christian Griebel
+   Description: Defines functions to interface with the PCM post processing
+                module.
+
+   This software and/or program is protected by copyright law and international
+   treaties. Any reproduction or distribution of this software and/or program,
+   or any portion of it, may result in severe civil and criminal penalties, and
+   will be prosecuted to the maximum extent possible under law.
+
+*******************************************************************************/
+
+#include "pcmutils_lib.h"
+
+#include "genericStds.h"
+#include "fixpoint_math.h"
+
+/* Decoder library info */
+#define PCMDMX_LIB_VL0 2
+#define PCMDMX_LIB_VL1 2
+#define PCMDMX_LIB_VL2 0
+#define PCMDMX_LIB_TITLE "PCM Downmix Lib"
+#define PCMDMX_LIB_BUILD_DATE __DATE__
+#define PCMDMX_LIB_BUILD_TIME __TIME__
+
+/* Library settings */
+#define PCM_DMX_MAX_DELAY_FRAMES        ( 1 )
+#define PCM_DMX_MAX_CHANNELS            ( 8 )
+#define PCM_DMX_MAX_CHANNEL_GROUPS      ( 4 )
+#define PCM_DMX_MAX_CHANNELS_PER_GROUP  ( 3 )   /* The maximum over all groups */
+#define PCMDMX_DFLT_EXPIRY_FRAME        ( 40 )  /* At least 400ms (FL 960 @ 96kHz) */
+
+/* Fixed and unique channel group indices.
+ * The last group index has to be smaller than PCM_DMX_MAX_CHANNEL_GROUPS. */
+#define CH_GROUP_FRONT ( 0 )
+#define CH_GROUP_SIDE  ( 1 )
+#define CH_GROUP_REAR  ( 2 )
+#define CH_GROUP_LFE   ( 3 )
+
+/* 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 PCM_DMX_MAX_CHANNELS. */
+#define CENTER_FRONT_CHANNEL    ( 0 )     /* C  */
+#define LEFT_FRONT_CHANNEL      ( 1 )     /* L  */
+#define RIGHT_FRONT_CHANNEL     ( 2 )     /* R  */
+#define LEFT_OUTSIDE_CHANNEL    ( 3 )     /* Lo */
+#define RIGHT_OUTSIDE_CHANNEL   ( 4 )     /* Ro */
+#define LEFT_REAR_CHANNEL       ( 5 )     /* Lr  aka left back channel  */
+#define RIGHT_REAR_CHANNEL      ( 6 )     /* Rr  aka right back channel */
+#define LOW_FREQUENCY_CHANNEL   ( 7 )     /* Lf */
+
+/* More constants */
+#define ANC_DATA_SYNC_BYTE      ( 0xBC )  /* ancillary data sync byte. */
+#define ATTENUATION_FACTOR_1    ( FL2FXCONST_SGL(0.70710678f) )
+#define TWO_CHANNEL             ( 2 )
+
+/* Sanity checks on library setting: */
+
+/* List of packed channel modes */
+typedef enum
+{ /* CH_MODE_<numFrontCh>_<numOutsideCh>_<numRearCh>_<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,
+  /* 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,
+  /* 6 channels */
+  CH_MODE_3_0_2_1   = 0x1203,   /* chCfg 6 */
+  CH_MODE_3_2_1_0   = 0x0123,
+  /* 7 channels */
+  CH_MODE_2_2_2_1   = 0x1222,
+  CH_MODE_3_2_1_1   = 0x1123,
+  CH_MODE_3_2_2_0   = 0x0223,
+  /* 8 channels */
+  CH_MODE_3_2_2_1   = 0x1222,   /* chCfg 7 */
+  CH_MODE_3_2_1_2   = 0x2123,
+  CH_MODE_2_2_2_2   = 0x2222
+
+} 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[PCM_DMX_MAX_CHANNELS] =
+{
+  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_2_2_0,  /* 7 channels */
+  CH_MODE_3_2_2_1   /* 8 channels */
+};
+
+static const FIXP_SGL dvbDownmixFactors[8] =
+{
+  FL2FXCONST_SGL(1.0f),
+  FL2FXCONST_SGL(0.841f),
+  FL2FXCONST_SGL(0.707f),
+  FL2FXCONST_SGL(0.596f),
+  FL2FXCONST_SGL(0.500f),
+  FL2FXCONST_SGL(0.422f),
+  FL2FXCONST_SGL(0.355f),
+  FL2FXCONST_SGL(0.0f)
+};
+
+
+  /* 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_SGL mpegMixDownIdx2Coef[4] =
+  {
+    FL2FXCONST_SGL(0.70710678f),
+    FL2FXCONST_SGL(0.5f),
+    FL2FXCONST_SGL(0.35355339f),
+    FL2FXCONST_SGL(0.0f)
+  };
+
+  static const FIXP_SGL mpegMixDownIdx2PreFact[4] =
+  {
+    FL2FXCONST_SGL(0.4142135623730950f),
+    FL2FXCONST_SGL(0.4530818393219728f),
+    FL2FXCONST_SGL(0.4852813742385703f),
+    FL2FXCONST_SGL(0.5857864376269050f)
+  };
+
+  typedef struct
+  {
+    USHORT  matrixMixdownIdx;       /*!< MPEG mixdown index extracted from PCE.            */
+    USHORT  pseudoSurroundEnable;   /*!< Pseudo surround enable flag extracted from PCE.   */
+    USHORT  mixdownAvailable;       /*!< Will be set to 1 if we found a valid coefficient. */
+
+  } MPEG_MIXDOWN_INFO;
+
+
+typedef struct
+{
+  FIXP_SGL  centerMixLevelValue;    /*!< DVB mixdown level for the center channel extracted from anc data.  */
+  FIXP_SGL  surroundMixLevelValue;  /*!< DVB mixdown level for back channels extracted from anc data.       */
+
+  UCHAR     mixLevelsAvail;         /*!< Will be set to 1 if we found a valid coefficient.                  */
+
+} DVB_MIXDOWN_LEVELS;
+
+
+/* Modules main data structure: */
+struct PCM_DMX_INSTANCE
+{
+  DVB_MIXDOWN_LEVELS  dvbMixDownLevels[PCM_DMX_MAX_DELAY_FRAMES+1];
+  MPEG_MIXDOWN_INFO   mpegMixDownInfo[PCM_DMX_MAX_DELAY_FRAMES+1];
+  DUAL_CHANNEL_MODE dualChannelMode;
+  UINT expiryFrame;
+  UINT expiryCount;
+  SHORT numOutputChannels;
+  UCHAR applyProcessing;
+  UCHAR frameDelay;
+};
+
+/* Memory allocation macro */
+C_ALLOC_MEM_STATIC(PcmDmxInstance, struct PCM_DMX_INSTANCE, 1)
+
+
+/** Evaluate a given channel configuration and extract a packed channel mode and generate a channel offset table
+ *  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 [in] Array containing the channel mapping to be used (From MPEG PCE ordering to whatever is required).
+ * @param [out] Array where the buffer offsets for each channel are stored into.
+ * @returns Returns the packed channel mode.
+ **/
+static
+PCM_DMX_CHANNEL_MODE getChannelMode (
+        const INT                numChannels,                           /* in */
+        const AUDIO_CHANNEL_TYPE channelType[],                         /* in */
+        const UCHAR              channelIndices[],                      /* in */
+        const UCHAR              channelMapping[PCM_DMX_MAX_CHANNELS],  /* in */
+        UCHAR                    offsetTable[PCM_DMX_MAX_CHANNELS]      /* out */
+      )
+{
+  UINT  chMode = CH_MODE_UNDEFINED;
+  UCHAR chIdx[PCM_DMX_MAX_CHANNEL_GROUPS][PCM_DMX_MAX_CHANNELS_PER_GROUP];
+  UCHAR numChInGrp[PCM_DMX_MAX_CHANNEL_GROUPS];
+  int   ch, grpIdx, err = 0;
+
+  FDK_ASSERT(channelType != NULL);
+  FDK_ASSERT(channelIndices != NULL);
+  FDK_ASSERT(channelMapping != NULL);
+  FDK_ASSERT(offsetTable != NULL);
+
+  /* For details see ISO/IEC 13818-7:2005(E), 8.5.3 Channel configuration */
+  FDKmemclear(numChInGrp, PCM_DMX_MAX_CHANNEL_GROUPS*sizeof(UCHAR));
+  FDKmemset(offsetTable, 255, PCM_DMX_MAX_CHANNELS*sizeof(UCHAR));
+
+  /* Categorize channels */
+  for (ch = 0; ch < numChannels; ch += 1) {
+    int i = 0, j, chGrpIdx = channelIndices[ch];
+
+    switch (channelType[ch]) {
+    case ACT_FRONT:
+    case ACT_FRONT_TOP:
+      grpIdx = CH_GROUP_FRONT;
+      break;
+    case ACT_SIDE:
+    case ACT_SIDE_TOP:
+      grpIdx = CH_GROUP_SIDE;
+      break;
+    case ACT_BACK:
+    case ACT_BACK_TOP:
+      grpIdx = CH_GROUP_REAR;
+      break;
+    case ACT_LFE:
+      grpIdx = CH_GROUP_LFE;
+      break;
+    default:
+      err = -1;
+      continue;
+    }
+
+    if (numChInGrp[grpIdx] < PCM_DMX_MAX_CHANNELS_PER_GROUP) {
+      /* Sort channels by index */
+      while ( (i < numChInGrp[grpIdx]) && (chGrpIdx > channelIndices[chIdx[grpIdx][i]]) ) {
+        i += 1;
+      }
+      for (j = numChInGrp[grpIdx]; j > i; j -= 1) {
+        chIdx[grpIdx][j] = chIdx[grpIdx][j-1];
+      }
+      chIdx[grpIdx][i] = ch;
+      numChInGrp[grpIdx] += 1;
+    }
+  }
+
+  /* Compose channel offset table */
+
+  /* Non-symmetric channels */
+  if (numChInGrp[CH_GROUP_FRONT] & 0x1) {
+    /* Odd number of front channels -> we have a center channel.
+       In MPEG-4 the center has the index 0. */
+    offsetTable[CENTER_FRONT_CHANNEL] = channelMapping[chIdx[CH_GROUP_FRONT][0]];
+  }
+
+  for (grpIdx = 0; grpIdx < PCM_DMX_MAX_CHANNEL_GROUPS; grpIdx += 1) {
+    int chMapPos, maxChannels = 0;
+    ch = 0;
+
+    switch (grpIdx) {
+    case CH_GROUP_FRONT:
+      chMapPos = LEFT_FRONT_CHANNEL;
+      maxChannels = 3;
+      ch = numChInGrp[grpIdx] & 0x1;
+      break;
+    case CH_GROUP_SIDE:
+      chMapPos = LEFT_OUTSIDE_CHANNEL;
+      maxChannels = 2;
+      break;
+    case CH_GROUP_REAR:
+      chMapPos = LEFT_REAR_CHANNEL;
+      maxChannels = 2;
+      break;
+    case CH_GROUP_LFE:
+      chMapPos = LOW_FREQUENCY_CHANNEL;
+      maxChannels = 1;
+      break;
+    default:
+      err = -1;
+      continue;
+    }
+
+    for ( ; ch < numChInGrp[grpIdx]; ch += 1) {
+      if (ch < maxChannels) {
+        offsetTable[chMapPos] = channelMapping[chIdx[grpIdx][ch]];
+        chMapPos += 1;
+      } else {
+        err = -1;
+      }
+    }
+  }
+
+  if (err == 0) {
+    /* Compose the channel mode */
+    chMode = (numChInGrp[CH_GROUP_LFE]   & 0xF) << 12
+           | (numChInGrp[CH_GROUP_REAR]  & 0xF) <<  8
+           | (numChInGrp[CH_GROUP_SIDE]  & 0xF) <<  4
+           | (numChInGrp[CH_GROUP_FRONT] & 0xF);
+  }
+
+  return (PCM_DMX_CHANNEL_MODE)chMode;
+}
+
+
+/** Generate a channel offset table and complete channel description for a given (packed) channel mode.
+ *  This function is the inverse to the getChannelMode() routine.
+ * @param [in] The total number of channels of the given configuration.
+ * @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.
+ **/
+void getChannelDescription (
+        const PCM_DMX_CHANNEL_MODE  chMode,                                 /* in */
+        const UCHAR                 channelMapping[][PCM_DMX_MAX_CHANNELS], /* in */
+        AUDIO_CHANNEL_TYPE          channelType[],                          /* out */
+        UCHAR                       channelIndices[],                       /* out */
+        UCHAR                       offsetTable[PCM_DMX_MAX_CHANNELS]       /* out */
+      )
+{
+  const UCHAR *pChannelMap;
+  int   grpIdx, ch = 0, numChannels = 0;
+  UCHAR numChInGrp[PCM_DMX_MAX_CHANNEL_GROUPS];
+
+  FDK_ASSERT(channelType != NULL);
+  FDK_ASSERT(channelIndices != NULL);
+  FDK_ASSERT(channelMapping != NULL);
+  FDK_ASSERT(offsetTable != NULL);
+
+  /* Init output arrays */
+  FDKmemclear(channelType,    PCM_DMX_MAX_CHANNELS*sizeof(AUDIO_CHANNEL_TYPE));
+  FDKmemclear(channelIndices, PCM_DMX_MAX_CHANNELS*sizeof(UCHAR));
+  FDKmemset(offsetTable, 255, PCM_DMX_MAX_CHANNELS*sizeof(UCHAR));
+
+  /* Extract the number of channels per group */
+  numChInGrp[CH_GROUP_FRONT] =  chMode        & 0xF;
+  numChInGrp[CH_GROUP_SIDE]  = (chMode >>  4) & 0xF;
+  numChInGrp[CH_GROUP_REAR]  = (chMode >>  8) & 0xF;
+  numChInGrp[CH_GROUP_LFE]   = (chMode >> 12) & 0xF;
+
+  /* Summerize to get the total number of channels */
+  for (grpIdx = 0; grpIdx < PCM_DMX_MAX_CHANNEL_GROUPS; grpIdx += 1) {
+    numChannels += numChInGrp[grpIdx];
+  }
+
+  /* Get the appropriate channel map */
+  pChannelMap = channelMapping[numChannels-1];
+
+  /* Compose channel offset table */
+
+  /* Non-symmetric channels */
+  if (numChInGrp[CH_GROUP_FRONT] & 0x1) {
+    /* Odd number of front channels -> we have a center channel.
+       In MPEG-4 the center has the index 0. */
+    offsetTable[CENTER_FRONT_CHANNEL] = pChannelMap[0];
+    channelType[0] = ACT_FRONT;
+    ch += 1;
+  }
+
+  for (grpIdx = 0; grpIdx < PCM_DMX_MAX_CHANNEL_GROUPS; grpIdx += 1) {
+    AUDIO_CHANNEL_TYPE type;
+    int chMapPos, maxChannels = 0;
+    int chIdx = 0;
+
+    switch (grpIdx) {
+    case CH_GROUP_FRONT:
+      type = ACT_FRONT;
+      chMapPos = LEFT_FRONT_CHANNEL;
+      maxChannels = 3;
+      chIdx = numChInGrp[grpIdx] & 0x1;
+      break;
+    case CH_GROUP_SIDE:
+      type = ACT_SIDE;
+      chMapPos = LEFT_OUTSIDE_CHANNEL;
+      maxChannels = 2;
+      break;
+    case CH_GROUP_REAR:
+      type = ACT_BACK;
+      chMapPos = LEFT_REAR_CHANNEL;
+      maxChannels = 2;
+      break;
+    case CH_GROUP_LFE:
+      type = ACT_LFE;
+      chMapPos = LOW_FREQUENCY_CHANNEL;
+      maxChannels = 1;
+      break;
+    default:
+      break;
+    }
+
+    for ( ; (chIdx < numChInGrp[grpIdx]) && (chIdx < maxChannels); chIdx += 1) {
+      offsetTable[chMapPos] = pChannelMap[ch];
+      channelType[ch]    = type;
+      channelIndices[ch] = chIdx;
+      chMapPos += 1;
+      ch += 1;
+    }
+  }
+}
+
+
+/** 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) {
+    self->dualChannelMode   = STEREO_MODE;
+    self->numOutputChannels = 0;
+    self->applyProcessing   = 0;
+    self->frameDelay        = 0;
+    self->expiryFrame       = PCMDMX_DFLT_EXPIRY_FRAME;
+  }
+
+  if (flags & PCMDMX_RESET_BS_DATA) {
+    int slot;
+    for (slot = 0; slot <= PCM_DMX_MAX_DELAY_FRAMES; slot += 1) {
+      self->dvbMixDownLevels[slot].centerMixLevelValue    = dvbDownmixFactors[2]; /* 0.707 */
+      self->dvbMixDownLevels[slot].surroundMixLevelValue  = dvbDownmixFactors[0]; /* 1.000 */
+      self->dvbMixDownLevels[slot].mixLevelsAvail = 0;
+
+      self->mpegMixDownInfo[slot].mixdownAvailable = 0;
+    }
+    /* Reset expiry counter */
+    self->expiryCount = 0;
+  }
+
+  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,
+    PCMDMX_PARAM        param,
+    UINT                value
+  )
+{
+  switch (param)
+  {
+  case DMX_BS_DATA_EXPIRY_FRAME:
+    if (self == NULL)
+      return (PCMDMX_INVALID_HANDLE);
+    self->expiryFrame = value;
+    break;
+
+  case DMX_BS_DATA_DELAY:
+    if (value > PCM_DMX_MAX_DELAY_FRAMES) {
+      return (PCMDMX_UNABLE_TO_SET_PARAM);
+    }
+    if (self == NULL) {
+      return (PCMDMX_INVALID_HANDLE);
+    }
+    self->frameDelay = value;
+    break;
+
+  case NUMBER_OF_OUTPUT_CHANNELS:
+    switch ((int)value) {  /* supported output channels */
+    case -1: case 0: case 1: case 2:
+    case 6: case 8:
+      break;
+    default:
+      return (PCMDMX_UNABLE_TO_SET_PARAM);
+    }
+    if (self == NULL)
+      return (PCMDMX_INVALID_HANDLE);
+    if ((int)value > 0) {
+      self->numOutputChannels = (int)value;
+      self->applyProcessing = 1;
+    } else {
+      self->numOutputChannels = 0;
+      self->applyProcessing = 0;
+    }
+    break;
+
+  case DUAL_CHANNEL_DOWNMIX_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->dualChannelMode = (DUAL_CHANNEL_MODE)value;
+    self->applyProcessing = 1;
+    break;
+
+  default:
+    return (PCMDMX_UNKNOWN_PARAM);
+  }
+
+  return (PCMDMX_OK);
+}
+
+
+/** Read the ancillary data transported in DSEs of DVB streams with MPEG-4 content
+ * @param [in] Handle of PCM downmix module instance.
+ * @param [in] Pointer to ancillary data buffer.
+ * @param [in] Size of ancillary data.
+ * @param [in] Flag indicating wheter the DVB ancillary data is from an MPEG-1/2 or an MPEG-4 stream.
+ * @returns Returns an error code.
+ **/
+PCMDMX_ERROR pcmDmx_ReadDvbAncData (
+    HANDLE_PCM_DOWNMIX  self,
+    UCHAR *pAncDataBuf,
+    UINT   ancDataBytes,
+    int    isMpeg2
+  )
+{
+  DVB_MIXDOWN_LEVELS *pDownmixLevels = &self->dvbMixDownLevels[0];
+
+  int   offset = (isMpeg2) ? 2 : 0;
+  UCHAR ancDataStatus;
+
+  if (self == NULL) { return (PCMDMX_INVALID_HANDLE); }
+
+  /* sanity checks */
+  if (pAncDataBuf == NULL || ancDataBytes < (UCHAR)(3+offset)) {
+    return (PCMDMX_CORRUPT_ANC_DATA);
+  }
+
+  /* check sync word */
+  if (pAncDataBuf[offset] != ANC_DATA_SYNC_BYTE) {
+    return (PCMDMX_CORRUPT_ANC_DATA);
+  }
+
+  offset += 2;
+  ancDataStatus = pAncDataBuf[offset++];
+
+  if (isMpeg2) {
+    /* skip advanced_dynamic_range_control */
+    if (ancDataStatus & 0x80) offset += 3;
+    /* skip dialog_normalization */
+    if (ancDataStatus & 0x40) offset += 1;
+    /* skip reproduction_level */
+    if (ancDataStatus & 0x20) offset += 1;
+  }
+  else {
+    /* check reserved bits */
+    if (ancDataStatus & 0xE8) { return (PCMDMX_CORRUPT_ANC_DATA); }
+  }
+
+  /* downmix_levels_MPEGX */
+  if (ancDataStatus & 0x10)
+  {
+    int   foundNewData = 0;
+    UCHAR downmixData = pAncDataBuf[offset++];
+
+    if (downmixData & 0x80) {  /* center_mix_level_on */
+      pDownmixLevels->centerMixLevelValue =
+        dvbDownmixFactors[(downmixData >> 4) & 0x07];
+      foundNewData = 1;
+    } else {
+      pDownmixLevels->centerMixLevelValue = dvbDownmixFactors[0];
+      if (downmixData & 0x70) { return (PCMDMX_CORRUPT_ANC_DATA); }
+    }
+
+    if (downmixData & 0x08) {  /* surround_mix_level_on */
+      pDownmixLevels->surroundMixLevelValue =
+        dvbDownmixFactors[downmixData & 0x07];
+      foundNewData = 1;
+    } else {
+      pDownmixLevels->surroundMixLevelValue = dvbDownmixFactors[0];
+      if (downmixData & 0x07) { return (PCMDMX_CORRUPT_ANC_DATA); }
+    }
+
+    pDownmixLevels->mixLevelsAvail = foundNewData;
+  }
+
+  /* Reset expiry counter */
+  self->expiryCount = 0;
+
+  return (PCMDMX_OK);
+}
+
+/** 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
+  )
+{
+  MPEG_MIXDOWN_INFO *pMpegMixDownInfo;
+
+  if (self == NULL) {
+    return (PCMDMX_INVALID_HANDLE);
+  }
+
+  pMpegMixDownInfo = &self->mpegMixDownInfo[0];
+
+  if (matrixMixdownPresent) {
+    pMpegMixDownInfo->matrixMixdownIdx     = matrixMixdownIdx & 0x03;
+    pMpegMixDownInfo->pseudoSurroundEnable = pseudoSurroundEnable;
+  }
+
+  pMpegMixDownInfo->mixdownAvailable = matrixMixdownPresent;
+  /* Reset expiry counter */
+  self->expiryCount = 0;
+
+  return (PCMDMX_OK);
+}
+
+
+/** Apply down or up mixing.
+ * @param [in]    Handle of PCM downmix module instance.
+ * @param [inout] Pointer to time buffer. Depending on interface configuration, the content of pTimeData is ignored,
+ *                and the internal QMF buffer will be used as input data source. Otherwise, the MPEG Surround processing is
+ *                applied to the timesignal pTimeData. For both variants, the resulting MPEG Surround signal is written into pTimeData.
+ * @param [in]    Pointer where the amount of output samples is returned into.
+ * @param [inout] Pointer where the amount of output channels is returned into.
+ * @param [in]    Flag which indicates if output time data are writtern interleaved or as subsequent blocks.
+ * @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 output channel mapping to be used (From MPEG PCE ordering to whatever is required).
+ * @returns Returns an error code.
+ **/
+PCMDMX_ERROR pcmDmx_ApplyFrame (
+        HANDLE_PCM_DOWNMIX      self,
+        INT_PCM                *pPcmBuf,
+        UINT                    frameSize,
+        INT                    *nChannels,
+
+        int                     fInterleaved,
+        AUDIO_CHANNEL_TYPE      channelType[],
+        UCHAR                   channelIndices[],
+        const UCHAR             channelMapping[][8]
+  )
+{
+  PCMDMX_ERROR  errorStatus = PCMDMX_OK;
+  DUAL_CHANNEL_MODE  dualChannelMode;
+  PCM_DMX_CHANNEL_MODE  inChMode;
+  int   numOutChannels;
+  int   numInChannels = *nChannels;
+  int   slot;
+  UCHAR inOffsetTable[PCM_DMX_MAX_CHANNELS];
+
+  MPEG_MIXDOWN_INFO   mpegMixDownInfo;
+  DVB_MIXDOWN_LEVELS  dvbMixDownLevels;
+
+  if (self == NULL) { return (PCMDMX_INVALID_HANDLE); }
+
+  if ( (self->expiryFrame > 0)
+    && (++self->expiryCount > self->expiryFrame) )
+  { /* The metadata read from bitstream is too old. */
+    errorStatus = pcmDmx_Reset(self, PCMDMX_RESET_BS_DATA);
+  }
+
+  FDKmemcpy(&mpegMixDownInfo, &self->mpegMixDownInfo[self->frameDelay], sizeof(MPEG_MIXDOWN_INFO));
+  /* Maintain delay line */
+  for (slot = self->frameDelay; slot > 0; slot -= 1) {
+    FDKmemcpy(&self->mpegMixDownInfo[slot], &self->mpegMixDownInfo[slot-1], sizeof(MPEG_MIXDOWN_INFO));
+  }
+  FDKmemcpy(&dvbMixDownLevels, &self->dvbMixDownLevels[self->frameDelay], sizeof(DVB_MIXDOWN_LEVELS));
+  /* Maintain delay line */
+  for (slot = self->frameDelay; slot > 0; slot -= 1) {
+    FDKmemcpy(&self->dvbMixDownLevels[slot], &self->dvbMixDownLevels[slot-1], sizeof(DVB_MIXDOWN_LEVELS));
+  }
+
+  if (self->applyProcessing == 0) { return (errorStatus); }
+
+  if (pPcmBuf == NULL)     { return (PCMDMX_INVALID_ARGUMENT); }
+  if (frameSize == 0)      { return (PCMDMX_INVALID_ARGUMENT); }
+  if (numInChannels == 0)  { return (PCMDMX_INVALID_ARGUMENT); }
+
+  if (self->numOutputChannels <= 0) {
+    numOutChannels = numInChannels;
+  } else {
+    numOutChannels = self->numOutputChannels;
+  }
+  dualChannelMode = self->dualChannelMode;
+
+  /* Analyse input channel configuration and get channel offset
+   * table that can be accessed with the fixed channel labels. */
+  inChMode = getChannelMode(
+                   numInChannels,
+                   channelType,
+                   channelIndices,
+                   channelMapping[numInChannels],
+                   inOffsetTable
+                 );
+  if (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);
+  }
+
+  /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+  if ( numInChannels > numOutChannels )
+  { /* Apply downmix */
+    INT_PCM  *pInCF, *pInLF, *pInRF, *pInLO, *pInRO, *pInLR, *pInRR, *pOutL, *pOutR;
+    FIXP_SGL  flev, clev, slev;
+
+    UINT   sample;
+    int    inStride, outStride, offset;
+    int    useGuidedDownMix = 0;
+    UCHAR  outOffsetTable[PCM_DMX_MAX_CHANNELS];
+
+    /* Set I/O strides and offsets */
+    if (fInterleaved) {
+      inStride  = numInChannels;
+      outStride = TWO_CHANNEL;   /* The output of STAGE ONE is always STEREO !!!
+                                    STAGE TWO creates a downmix to mono if required. */
+      offset = 1;                /* Channel specific offset factor */
+    } else {
+      inStride  = 1;
+      outStride = 1;
+      offset = frameSize;        /* Channel specific offset factor */
+    }
+
+    /* Get channel description and channel mapping for this
+     * stages number of output channels (always STEREO). */
+    getChannelDescription(
+            CH_MODE_2_0_0_0,
+            channelMapping,
+            channelType,
+            channelIndices,
+            outOffsetTable
+           );
+    /* Now there is no way back because we modified the channel configuration! */
+
+    /* Set channel pointer for input */
+    pInCF = &pPcmBuf[inOffsetTable[CENTER_FRONT_CHANNEL]*offset];
+    pInLF = &pPcmBuf[inOffsetTable[LEFT_FRONT_CHANNEL]*offset];
+    pInRF = &pPcmBuf[inOffsetTable[RIGHT_FRONT_CHANNEL]*offset];
+    pInLO = &pPcmBuf[inOffsetTable[LEFT_OUTSIDE_CHANNEL]*offset];
+    pInRO = &pPcmBuf[inOffsetTable[RIGHT_OUTSIDE_CHANNEL]*offset];
+    pInLR = &pPcmBuf[inOffsetTable[LEFT_REAR_CHANNEL]*offset];
+    pInRR = &pPcmBuf[inOffsetTable[RIGHT_REAR_CHANNEL]*offset];
+
+    /* Set channel pointer for output
+       Caution: Different channel mapping compared to input */
+    pOutL = &pPcmBuf[outOffsetTable[LEFT_FRONT_CHANNEL]*offset];    /* LEFT_FRONT_CHANNEL  */
+    pOutR = &pPcmBuf[outOffsetTable[RIGHT_FRONT_CHANNEL]*offset];   /* RIGHT_FRONT_CHANNEL */
+
+    /* Set downmix levels: */
+    flev = ATTENUATION_FACTOR_1;    /* 0.707 */
+    clev = ATTENUATION_FACTOR_1;    /* 0.707 */
+    slev = ATTENUATION_FACTOR_1;    /* 0.707 */
+
+    if ( dvbMixDownLevels.mixLevelsAvail ) {
+      clev = dvbMixDownLevels.centerMixLevelValue;
+      slev = dvbMixDownLevels.surroundMixLevelValue;
+      useGuidedDownMix = 1;
+    }
+
+    /* FIRST STAGE:
+         Always downmix to 2 channel output: */
+    switch ( inChMode )
+    {
+    case CH_MODE_2_0_0_0:
+    case CH_MODE_2_0_0_1: 
+      /* 2/0 input: */
+      switch (dualChannelMode)
+      {
+      case CH1_MODE:  /* L' = 0.707 * Ch1;  R' = 0.707 * Ch1 */
+        for (sample = 0; sample < frameSize; sample++) {
+          *pOutL = *pOutR =
+            (INT_PCM)SATURATE_RIGHT_SHIFT(fMult((FIXP_PCM)*pInLF, flev), DFRACT_BITS-SAMPLE_BITS, SAMPLE_BITS);
+
+          pInLF += 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 =
+            (INT_PCM)SATURATE_RIGHT_SHIFT(fMult((FIXP_PCM)*pInRF, flev), DFRACT_BITS-SAMPLE_BITS, SAMPLE_BITS);
+
+          pInRF += 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 = (*pInLF >> 1) + (*pInRF >> 1);
+
+          pInLF += inStride;  pInRF += inStride;
+          pOutL += outStride; pOutR += outStride;
+        }
+        break;
+      default:
+      case STEREO_MODE:
+        /* nothing to do */
+        break;
+      }
+      break;
+
+    case CH_MODE_3_0_0_0:
+      /* 3/0 input:  L' = L + 0.707*C;  R' = R + 0.707*C; */
+      for (sample = 0; sample < frameSize; sample++)
+      {
+        FIXP_DBL tCF = fMultDiv2((FIXP_PCM)*pInCF, clev);
+#if (SAMPLE_BITS == 32)
+        /* left channel */
+        *pOutL = (INT_PCM)SATURATE_LEFT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInLF)>>1)+tCF, 1, SAMPLE_BITS);
+        /* right channel */
+        *pOutR = (INT_PCM)SATURATE_LEFT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInRF)>>1)+tCF, 1, SAMPLE_BITS);
+#else
+        /* left channel */
+        *pOutL = (INT_PCM)SATURATE_RIGHT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInLF)>>1)+tCF, DFRACT_BITS-SAMPLE_BITS-1, SAMPLE_BITS);
+        /* right channel */
+        *pOutR = (INT_PCM)SATURATE_RIGHT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInRF)>>1)+tCF, DFRACT_BITS-SAMPLE_BITS-1, SAMPLE_BITS);
+#endif
+        pInLF += inStride;  pInRF += inStride;  pInCF  += inStride;
+        pOutL += outStride; pOutR += outStride;
+      }
+      break;
+
+    /* 2/1 input: not supported!
+    case CH_MODE_2_0_1_0: */
+
+    case CH_MODE_3_0_1_0:
+      if (useGuidedDownMix) {
+        /* 3/1 input:  L' = L + clev*C + 0.707*slev*S;  R' = R + clev*C + 0.707*slev*S; */
+        slev = FX_DBL2FX_SGL(fMult(flev, slev));  /* 0.707*slef */
+
+        for (sample = 0; sample < frameSize; sample++)
+        {
+          FIXP_DBL tCF = fMultDiv2((FIXP_PCM)*pInCF, clev) >> 1;
+          FIXP_DBL tLR = fMultDiv2((FIXP_PCM)*pInLR, slev) >> 1;
+#if (SAMPLE_BITS == 32)
+          /* left channel */
+          *pOutL = (INT_PCM)SATURATE_LEFT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInLF)>>2)+tCF+tLR, 2, SAMPLE_BITS);
+          /* right channel */
+          *pOutR = (INT_PCM)SATURATE_LEFT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInRF)>>2)+tCF+tLR, 2, SAMPLE_BITS);
+#else
+          /* left channel */
+          *pOutL = (INT_PCM)SATURATE_RIGHT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInLF)>>2)+tCF-tLR, DFRACT_BITS-SAMPLE_BITS-2, SAMPLE_BITS);
+          /* right channel */
+          *pOutR = (INT_PCM)SATURATE_RIGHT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInRF)>>2)+tCF+tLR, DFRACT_BITS-SAMPLE_BITS-2, SAMPLE_BITS);
+#endif
+          pInLF += inStride;  pInRF += inStride;  pInCF  += inStride;  pInLR  += inStride;
+          pOutL += outStride; pOutR += outStride;
+        }
+      } else {
+        /* 3/1 input:  L' = L + 0.707*C - 0.707*S;  R' = R + 0.707*C + 0.707*S */
+        for (sample = 0; sample < frameSize; sample++)
+        {
+          FIXP_DBL tCF = fMultDiv2((FIXP_PCM)*pInCF, clev) >> 1;
+          FIXP_DBL tLR = fMultDiv2((FIXP_PCM)*pInLR, slev) >> 1;
+#if (SAMPLE_BITS == 32)
+          /* left channel */
+          *pOutL = (INT_PCM)SATURATE_LEFT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInLF)>>2)+tCF-tLR, 2, SAMPLE_BITS);
+          /* right channel */
+          *pOutR = (INT_PCM)SATURATE_LEFT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInRF)>>2)+tCF+tLR, 2, SAMPLE_BITS);
+#else
+          /* left channel */
+          *pOutL = (INT_PCM)SATURATE_RIGHT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInLF)>>2)+tCF-tLR, DFRACT_BITS-SAMPLE_BITS-2, SAMPLE_BITS);
+          /* right channel */
+          *pOutR = (INT_PCM)SATURATE_RIGHT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInRF)>>2)+tCF+tLR, DFRACT_BITS-SAMPLE_BITS-2, SAMPLE_BITS);
+#endif
+          pInLF += inStride;  pInRF += inStride;  pInCF  += inStride;  pInLR  += inStride;
+          pOutL += outStride; pOutR += outStride;
+        }
+      }
+      break;
+
+    /* 2/2 input: not supported!
+    case CH_MODE_2_0_2_0: */
+
+    case CH_MODE_3_0_2_0:   /* 5.0ch input */
+    case CH_MODE_3_0_2_1:   /* 5.1ch input */
+      if (useGuidedDownMix) {
+        /* 3/2 input:  L' = L + clev*C + slev*Ls;  R' = R + clev*C + slev*Rs; */
+        for (sample = 0; sample < frameSize; sample++)
+        {
+          FIXP_DBL tCF = fMultDiv2((FIXP_PCM)*pInCF, clev) >> 1;
+          FIXP_DBL tLR = fMultDiv2((FIXP_PCM)*pInLR, slev) >> 1;
+          FIXP_DBL tRR = fMultDiv2((FIXP_PCM)*pInRR, slev) >> 1;
+#if (SAMPLE_BITS == 32)
+          /* left channel */
+          *pOutL = (INT_PCM)SATURATE_LEFT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInLF)>>2)+tCF+tLR, 2, SAMPLE_BITS);
+          /* right channel */
+          *pOutR = (INT_PCM)SATURATE_LEFT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInRF)>>2)+tCF+tRR, 2, SAMPLE_BITS);
+#else
+          /* left channel */
+          *pOutL = (INT_PCM)SATURATE_RIGHT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInLF)>>2)+tCF+tLR, DFRACT_BITS-SAMPLE_BITS-2, SAMPLE_BITS);
+          /* right channel */
+          *pOutR = (INT_PCM)SATURATE_RIGHT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInRF)>>2)+tCF+tRR, DFRACT_BITS-SAMPLE_BITS-2, SAMPLE_BITS);
+#endif
+          pInLF += inStride;  pInRF += inStride;  pInCF  += inStride;  pInLR  += inStride;  pInRR  += inStride;
+          pOutL += outStride; pOutR += outStride;
+        }
+      }
+      else if (mpegMixDownInfo.mixdownAvailable) {
+        /* 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]; */
+        FIXP_SGL mtrxMixDwnCoef    = mpegMixDownIdx2Coef[mpegMixDownInfo.matrixMixdownIdx];
+        FIXP_SGL mtrxMixDwnPreFact = mpegMixDownIdx2PreFact[mpegMixDownInfo.matrixMixdownIdx];
+        clev = FX_DBL2FX_SGL(fMult(mtrxMixDwnPreFact, flev /* 0.707 */));
+        flev = mtrxMixDwnPreFact;
+        slev = FX_DBL2FX_SGL(fMult(mtrxMixDwnPreFact, mtrxMixDwnCoef));
+
+        for (sample = 0; sample < frameSize; sample++)
+        {
+          FIXP_DBL tCF = fMultDiv2((FIXP_PCM)*pInCF, clev);
+          FIXP_DBL tLF = fMultDiv2((FIXP_PCM)*pInLF, flev);
+          FIXP_DBL tRF = fMultDiv2((FIXP_PCM)*pInRF, flev);
+          FIXP_DBL tLR = fMultDiv2((FIXP_PCM)*pInLR, slev);
+          FIXP_DBL tRR = fMultDiv2((FIXP_PCM)*pInRR, slev);
+
+#if (SAMPLE_BITS == 32)
+          /* left channel */
+          *pOutL = (INT_PCM)SATURATE_LEFT_SHIFT(tLF+tCF+tLR, 1, SAMPLE_BITS);
+          /* right channel */
+          *pOutR = (INT_PCM)SATURATE_LEFT_SHIFT(tRF+tCF+tRR, 1, SAMPLE_BITS);
+#else
+          /* left channel */
+          *pOutL = (INT_PCM)SATURATE_RIGHT_SHIFT(tLF+tCF+tLR, DFRACT_BITS-SAMPLE_BITS-1, SAMPLE_BITS);
+          /* right channel */
+          *pOutR = (INT_PCM)SATURATE_RIGHT_SHIFT(tRF+tCF+tRR, DFRACT_BITS-SAMPLE_BITS-1, SAMPLE_BITS);
+#endif
+
+          pInLF += inStride;  pInRF += inStride;  pInCF  += inStride;  pInLR  += inStride;  pInRR  += inStride;
+          pOutL += outStride; pOutR += outStride;
+        }
+      }
+      else {
+        /* 3/2 input:  L' = L + 0.707*C - 0.707*Ls - 0.707*Rs;  R' = R + 0.707*C + 0.707*Ls + 0.707*Rs */
+        for (sample = 0; sample < frameSize; sample++)
+        {
+          FIXP_DBL tCF = fMultDiv2((FIXP_PCM)*pInCF, clev) >> 2;
+          FIXP_DBL tLR = fMultDiv2((FIXP_PCM)*pInLR, slev) >> 2;
+          FIXP_DBL tRR = fMultDiv2((FIXP_PCM)*pInRR, slev) >> 2;
+#if (SAMPLE_BITS == 32)
+          /* left channel */
+          *pOutL = (INT_PCM)SATURATE_LEFT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInLF)>>3)+tCF-tLR-tRR, 3, SAMPLE_BITS);
+          /* right channel */
+          *pOutR = (INT_PCM)SATURATE_LEFT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInRF)>>3)+tCF+tLR+tRR, 3, SAMPLE_BITS);
+#else
+          /* left channel */
+          *pOutL = (INT_PCM)SATURATE_RIGHT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInLF)>>3)+tCF-tLR-tRR, DFRACT_BITS-SAMPLE_BITS-3, SAMPLE_BITS);
+          /* right channel */
+          *pOutR = (INT_PCM)SATURATE_RIGHT_SHIFT((FX_PCM2FX_DBL((FIXP_PCM)*pInRF)>>3)+tCF+tLR+tRR, DFRACT_BITS-SAMPLE_BITS-3, SAMPLE_BITS);
+#endif
+          pInLF += inStride;  pInRF += inStride;  pInCF  += inStride;  pInLR  += inStride;  pInRR  += inStride;
+          pOutL += outStride; pOutR += outStride;
+        }
+      }
+      break;
+
+    default:
+      errorStatus = PCMDMX_INVALID_MODE;
+      break;
+    }
+
+    /* SECOND STAGE:
+         If desired create a mono donwmix:
+         Note: Input are always two channels! */
+    if (numOutChannels == 1)
+    {
+      INT_PCM *pOutC;
+      FIXP_SGL mlev;
+
+      if (useGuidedDownMix) mlev = FL2FXCONST_SGL(1.0f); else mlev = flev;
+
+      /* Output of STAGE ONE = Input of STAGE TWO */
+      FDKmemcpy(inOffsetTable, outOffsetTable, PCM_DMX_MAX_CHANNELS*sizeof(UCHAR));
+
+      /* Set I/O strides and offsets */
+      inStride  = outStride;          /* output from STAGE ONE */
+      outStride = numOutChannels;     /* final output */
+
+      /* Get channel description and channel mapping for this
+       * stages number of output channels (always MONO). */
+      getChannelDescription(
+              CH_MODE_1_0_0_0,
+              channelMapping,
+              channelType,
+              channelIndices,
+              outOffsetTable
+             );
+
+      /* Set input channel pointer. */
+      pInLF = &pPcmBuf[inOffsetTable[LEFT_FRONT_CHANNEL]*offset];
+      pInRF = &pPcmBuf[inOffsetTable[RIGHT_FRONT_CHANNEL]*offset];
+
+      /* Set output channel pointer */
+      pOutC = &pPcmBuf[outOffsetTable[CENTER_FRONT_CHANNEL]*offset];
+
+      /* C' = 0.707*L + 0.707*R */
+      for (sample = 0; sample < frameSize; sample++) {
+#if (SAMPLE_BITS == 32)
+        *pOutC =
+          (INT_PCM)SATURATE_LEFT_SHIFT(fMultDiv2((FIXP_PCM)*pInLF,mlev)+fMultDiv2((FIXP_PCM)*pInRF,mlev), 1, SAMPLE_BITS);
+#else
+        *pOutC =
+          (INT_PCM)SATURATE_RIGHT_SHIFT(fMultDiv2((FIXP_PCM)*pInLF,mlev)+fMultDiv2((FIXP_PCM)*pInRF,mlev), DFRACT_BITS-SAMPLE_BITS-1, SAMPLE_BITS);
+#endif
+
+        pInLF += inStride; pInRF += inStride;
+        pOutC += 1;
+      }
+      /* Finished STAGE TWO */
+    }
+
+    /* Update the number of output channels */
+    *nChannels = self->numOutputChannels;
+
+  } /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+  else
+  if ( numInChannels == numOutChannels )
+  {
+    /* Don't need to change the channel description here */
+
+    switch (numInChannels)
+    {
+    case 2:
+      { /* Set up channel pointer */
+        INT_PCM *pInLF, *pInRF, *pOutL, *pOutR;
+        FIXP_SGL flev;
+
+        UINT sample;
+        int inStride, outStride, offset;
+
+        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 */
+        pInLF = &pPcmBuf[inOffsetTable[LEFT_FRONT_CHANNEL]*offset];
+        pInRF = &pPcmBuf[inOffsetTable[RIGHT_FRONT_CHANNEL]*offset];
+
+        /* Set output channel pointer (same as input) */
+        pOutL  =  pInLF;
+        pOutR  =  pInRF;
+
+        /* Set downmix levels: */
+        flev = ATTENUATION_FACTOR_1;    /* 0.707 */
+        /* 2/0 input: */
+        switch (dualChannelMode)
+        {
+        case CH1_MODE:  /* L' = 0.707 * Ch1;  R' = 0.707 * Ch1 */
+          for (sample = 0; sample < frameSize; sample++) {
+            *pOutL = *pOutR =
+              (INT_PCM)SATURATE_RIGHT_SHIFT(fMult((FIXP_PCM)*pInLF, flev), DFRACT_BITS-SAMPLE_BITS, SAMPLE_BITS);
+
+            pInLF += 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 =
+              (INT_PCM)SATURATE_RIGHT_SHIFT(fMult((FIXP_PCM)*pInRF, flev), DFRACT_BITS-SAMPLE_BITS, SAMPLE_BITS);
+
+            pInRF += 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 = (*pInLF >> 1) + (*pInRF >> 1);
+
+            pInLF += inStride;  pInRF += 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_UNKNOWN;
+  }
+  info += i;
+
+  /* Add the library info */
+  info->module_id  = FDK_PCMDMX;
+  info->version    = LIB_VERSION(PCMDMX_LIB_VL0, PCMDMX_LIB_VL1, PCMDMX_LIB_VL2);
+  LIB_VERSION_STRING(info);
+  info->build_date = PCMDMX_LIB_BUILD_DATE;
+  info->build_time = PCMDMX_LIB_BUILD_TIME;
+  info->title      = PCMDMX_LIB_TITLE;
+
+  /* Set flags */
+  info->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_DVB     /* Guided downmix with data from DVB ancillary data fields. */
+      ;
+
+  return PCMDMX_OK;
+}
+
+
+