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

Software License for The Fraunhofer FDK AAC Codec Library for Android

© Copyright  1995 - 2021 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;

}

/** Validates the channel indices of all channels present in the bitstream.

 * The channel indices have to be consecutive and unique for each audio channel

 *type.

 * @param [in] The total number of channels of the given configuration.

 * @param [in] The total number of channels of the current audio channel type of

 *the given configuration.

 * @param [in] Audio channel type to be examined.

 * @param [in] Array holding the corresponding channel types for each channel.

 * @param [in] Array holding the corresponding channel type indices for each

 *channel.

 * @returns Returns 1 on success, returns 0 on error.

 **/

static UINT validateIndices(UINT numChannels, UINT numChannelsPlaneAndGrp,

                            AUDIO_CHANNEL_TYPE aChType,

                            const AUDIO_CHANNEL_TYPE channelType[],

                            const UCHAR channelIndices[]) {

  for (UINT reqValue = 0; reqValue < numChannelsPlaneAndGrp; reqValue++) {

    int found = FALSE;

    for (UINT i = 0; i < numChannels; i++) {

      if (channelType[i] == aChType) {

        if (channelIndices[i] == reqValue) {

          if (found == TRUE) {

            return 0; /* Found channel index a second time */

          } else {

            found = TRUE; /* Found channel index */

          }

        }

      }

    }

    if (found == FALSE) {

      return 0; /* Did not find channel index */

    }

  }

  return 1; /* Successfully validated channel indices */

}

/** 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 */

) {

  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(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;

  }

  {

    int chGrp;

    /* Sanity check on the indices */

    for (chGrp = 0; chGrp < (4); chGrp += 1) {

      int plane;

      for (plane = 0; plane < (3); plane += 1) {

        if (numCh[plane][chGrp] == 0) continue;

        AUDIO_CHANNEL_TYPE aChType =

            (AUDIO_CHANNEL_TYPE)((plane << 4) | ((chGrp + 1) & 0xF));

        if (!validateIndices(numChannels, numCh[plane][chGrp], aChType,

                             channelType, channelIndices)) {

          unsigned idxCnt = 0;

          for (ch = 0; ch < numChannels; ch += 1) {

            if (channelType[ch] == aChType) {

              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);