Include patched FDK-AAC in the repository

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

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

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

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

1 files changed, 813 insertions, 0 deletions

diff --git a/fdk-aac/libFDK/src/FDK_hybrid.cpp b/fdk-aac/libFDK/src/FDK_hybrid.cpp
new file mode 100644
index 0000000..b661f82
--- /dev/null
+++ b/fdk-aac/libFDK/src/FDK_hybrid.cpp
@@ -0,0 +1,813 @@
+/* -----------------------------------------------------------------------------
+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
+----------------------------------------------------------------------------- */
+
+/******************* Library for basic calculation routines ********************
+
+   Author(s):   Markus Lohwasser
+
+   Description: FDK Tools Hybrid Filterbank
+
+*******************************************************************************/
+
+#include "FDK_hybrid.h"
+
+#include "fft.h"
+
+/*--------------- defines -----------------------------*/
+#define FFT_IDX_R(a) (2 * a)
+#define FFT_IDX_I(a) (2 * a + 1)
+
+#define HYB_COEF8_0 (0.00746082949812f)
+#define HYB_COEF8_1 (0.02270420949825f)
+#define HYB_COEF8_2 (0.04546865930473f)
+#define HYB_COEF8_3 (0.07266113929591f)
+#define HYB_COEF8_4 (0.09885108575264f)
+#define HYB_COEF8_5 (0.11793710567217f)
+#define HYB_COEF8_6 (0.12500000000000f)
+#define HYB_COEF8_7 (HYB_COEF8_5)
+#define HYB_COEF8_8 (HYB_COEF8_4)
+#define HYB_COEF8_9 (HYB_COEF8_3)
+#define HYB_COEF8_10 (HYB_COEF8_2)
+#define HYB_COEF8_11 (HYB_COEF8_1)
+#define HYB_COEF8_12 (HYB_COEF8_0)
+
+/*--------------- structure definitions ---------------*/
+
+#if defined(ARCH_PREFER_MULT_32x16)
+#define FIXP_HTB FIXP_SGL              /* SGL data type. */
+#define FIXP_HTP FIXP_SPK              /* Packed SGL data type. */
+#define HTC(a) (FX_DBL2FXCONST_SGL(a)) /* Cast to SGL */
+#define FL2FXCONST_HTB FL2FXCONST_SGL
+#else
+#define FIXP_HTB FIXP_DBL            /* SGL data type. */
+#define FIXP_HTP FIXP_DPK            /* Packed DBL data type. */
+#define HTC(a) ((FIXP_DBL)(LONG)(a)) /* Cast to DBL */
+#define FL2FXCONST_HTB FL2FXCONST_DBL
+#endif
+
+#define HTCP(real, imag)     \
+  {                          \
+    { HTC(real), HTC(imag) } \
+  } /* How to arrange the packed values. */
+
+struct FDK_HYBRID_SETUP {
+  UCHAR nrQmfBands;   /*!< Number of QMF bands to be converted to hybrid. */
+  UCHAR nHybBands[3]; /*!< Number of Hybrid bands generated by nrQmfBands. */
+  SCHAR kHybrid[3];   /*!< Filter configuration of each QMF band. */
+  UCHAR protoLen;     /*!< Prototype filter length. */
+  UCHAR filterDelay;  /*!< Delay caused by hybrid filter. */
+  const INT
+      *pReadIdxTable; /*!< Helper table to access input data ringbuffer. */
+};
+
+/*--------------- constants ---------------------------*/
+static const INT ringbuffIdxTab[2 * 13] = {0, 1,  2,  3,  4, 5,  6,  7, 8,
+                                           9, 10, 11, 12, 0, 1,  2,  3, 4,
+                                           5, 6,  7,  8,  9, 10, 11, 12};
+
+static const FDK_HYBRID_SETUP setup_3_16 = {3,  {8, 4, 4},    {8, 4, 4},
+                                            13, (13 - 1) / 2, ringbuffIdxTab};
+static const FDK_HYBRID_SETUP setup_3_12 = {3,  {8, 2, 2},    {8, 2, 2},
+                                            13, (13 - 1) / 2, ringbuffIdxTab};
+static const FDK_HYBRID_SETUP setup_3_10 = {3,  {6, 2, 2},    {-8, -2, 2},
+                                            13, (13 - 1) / 2, ringbuffIdxTab};
+
+static const FIXP_HTP HybFilterCoef8[] = {
+    HTCP(0x10000000, 0x00000000), HTCP(0x0df26407, 0xfa391882),
+    HTCP(0xff532109, 0x00acdef7), HTCP(0x08f26d36, 0xf70d92ca),
+    HTCP(0xfee34b5f, 0x02af570f), HTCP(0x038f276e, 0xf7684793),
+    HTCP(0x00000000, 0x05d1eac2), HTCP(0x00000000, 0x05d1eac2),
+    HTCP(0x038f276e, 0x0897b86d), HTCP(0xfee34b5f, 0xfd50a8f1),
+    HTCP(0x08f26d36, 0x08f26d36), HTCP(0xff532109, 0xff532109),
+    HTCP(0x0df26407, 0x05c6e77e)};
+
+static const FIXP_HTB HybFilterCoef2[3] = {FL2FXCONST_HTB(0.01899487526049f),
+                                           FL2FXCONST_HTB(-0.07293139167538f),
+                                           FL2FXCONST_HTB(0.30596630545168f)};
+
+static const FIXP_HTB HybFilterCoef4[13] = {FL2FXCONST_HTB(-0.00305151927305f),
+                                            FL2FXCONST_HTB(-0.00794862316203f),
+                                            FL2FXCONST_HTB(0.0f),
+                                            FL2FXCONST_HTB(0.04318924038756f),
+                                            FL2FXCONST_HTB(0.12542448210445f),
+                                            FL2FXCONST_HTB(0.21227807049160f),
+                                            FL2FXCONST_HTB(0.25f),
+                                            FL2FXCONST_HTB(0.21227807049160f),
+                                            FL2FXCONST_HTB(0.12542448210445f),
+                                            FL2FXCONST_HTB(0.04318924038756f),
+                                            FL2FXCONST_HTB(0.0f),
+                                            FL2FXCONST_HTB(-0.00794862316203f),
+                                            FL2FXCONST_HTB(-0.00305151927305f)};
+
+/*--------------- function declarations ---------------*/
+static INT kChannelFiltering(const FIXP_DBL *const pQmfReal,
+                             const FIXP_DBL *const pQmfImag,
+                             const INT *const pReadIdx,
+                             FIXP_DBL *const mHybridReal,
+                             FIXP_DBL *const mHybridImag,
+                             const SCHAR hybridConfig);
+
+/*--------------- function definitions ----------------*/
+
+INT FDKhybridAnalysisOpen(HANDLE_FDK_ANA_HYB_FILTER hAnalysisHybFilter,
+                          FIXP_DBL *const pLFmemory, const UINT LFmemorySize,
+                          FIXP_DBL *const pHFmemory, const UINT HFmemorySize) {
+  INT err = 0;
+
+  /* Save pointer to extern memory. */
+  hAnalysisHybFilter->pLFmemory = pLFmemory;
+  hAnalysisHybFilter->LFmemorySize = LFmemorySize;
+
+  hAnalysisHybFilter->pHFmemory = pHFmemory;
+  hAnalysisHybFilter->HFmemorySize = HFmemorySize;
+
+  return err;
+}
+
+INT FDKhybridAnalysisInit(HANDLE_FDK_ANA_HYB_FILTER hAnalysisHybFilter,
+                          const FDK_HYBRID_MODE mode, const INT qmfBands,
+                          const INT cplxBands, const INT initStatesFlag) {
+  int k;
+  INT err = 0;
+  FIXP_DBL *pMem = NULL;
+  HANDLE_FDK_HYBRID_SETUP setup = NULL;
+
+  switch (mode) {
+    case THREE_TO_TEN:
+      setup = &setup_3_10;
+      break;
+    case THREE_TO_TWELVE:
+      setup = &setup_3_12;
+      break;
+    case THREE_TO_SIXTEEN:
+      setup = &setup_3_16;
+      break;
+    default:
+      err = -1;
+      goto bail;
+  }
+
+  /* Initialize handle. */
+  hAnalysisHybFilter->pSetup = setup;
+  if (initStatesFlag) {
+    hAnalysisHybFilter->bufferLFpos = setup->protoLen - 1;
+    hAnalysisHybFilter->bufferHFpos = 0;
+  }
+  hAnalysisHybFilter->nrBands = qmfBands;
+  hAnalysisHybFilter->cplxBands = cplxBands;
+  hAnalysisHybFilter->hfMode = 0;
+
+  /* Check available memory. */
+  if (((2 * setup->nrQmfBands * setup->protoLen * sizeof(FIXP_DBL)) >
+       hAnalysisHybFilter->LFmemorySize)) {
+    err = -2;
+    goto bail;
+  }
+  if (hAnalysisHybFilter->HFmemorySize != 0) {
+    if (((setup->filterDelay *
+          ((qmfBands - setup->nrQmfBands) + (cplxBands - setup->nrQmfBands)) *
+          sizeof(FIXP_DBL)) > hAnalysisHybFilter->HFmemorySize)) {
+      err = -3;
+      goto bail;
+    }
+  }
+
+  /* Distribute LF memory. */
+  pMem = hAnalysisHybFilter->pLFmemory;
+  for (k = 0; k < setup->nrQmfBands; k++) {
+    hAnalysisHybFilter->bufferLFReal[k] = pMem;
+    pMem += setup->protoLen;
+    hAnalysisHybFilter->bufferLFImag[k] = pMem;
+    pMem += setup->protoLen;
+  }
+
+  /* Distribute HF memory. */
+  if (hAnalysisHybFilter->HFmemorySize != 0) {
+    pMem = hAnalysisHybFilter->pHFmemory;
+    for (k = 0; k < setup->filterDelay; k++) {
+      hAnalysisHybFilter->bufferHFReal[k] = pMem;
+      pMem += (qmfBands - setup->nrQmfBands);
+      hAnalysisHybFilter->bufferHFImag[k] = pMem;
+      pMem += (cplxBands - setup->nrQmfBands);
+    }
+  }
+
+  if (initStatesFlag) {
+    /* Clear LF buffer */
+    for (k = 0; k < setup->nrQmfBands; k++) {
+      FDKmemclear(hAnalysisHybFilter->bufferLFReal[k],
+                  setup->protoLen * sizeof(FIXP_DBL));
+      FDKmemclear(hAnalysisHybFilter->bufferLFImag[k],
+                  setup->protoLen * sizeof(FIXP_DBL));
+    }
+
+    if (hAnalysisHybFilter->HFmemorySize != 0) {
+      if (qmfBands > setup->nrQmfBands) {
+        /* Clear HF buffer */
+        for (k = 0; k < setup->filterDelay; k++) {
+          FDKmemclear(hAnalysisHybFilter->bufferHFReal[k],
+                      (qmfBands - setup->nrQmfBands) * sizeof(FIXP_DBL));
+          FDKmemclear(hAnalysisHybFilter->bufferHFImag[k],
+                      (cplxBands - setup->nrQmfBands) * sizeof(FIXP_DBL));
+        }
+      }
+    }
+  }
+
+bail:
+  return err;
+}
+
+INT FDKhybridAnalysisScaleStates(HANDLE_FDK_ANA_HYB_FILTER hAnalysisHybFilter,
+                                 const INT scalingValue) {
+  INT err = 0;
+
+  if (hAnalysisHybFilter == NULL) {
+    err = 1; /* invalid handle */
+  } else {
+    int k;
+    HANDLE_FDK_HYBRID_SETUP setup = hAnalysisHybFilter->pSetup;
+
+    /* Scale LF buffer */
+    for (k = 0; k < setup->nrQmfBands; k++) {
+      scaleValues(hAnalysisHybFilter->bufferLFReal[k], setup->protoLen,
+                  scalingValue);
+      scaleValues(hAnalysisHybFilter->bufferLFImag[k], setup->protoLen,
+                  scalingValue);
+    }
+    if (hAnalysisHybFilter->nrBands > setup->nrQmfBands) {
+      /* Scale HF buffer */
+      for (k = 0; k < setup->filterDelay; k++) {
+        scaleValues(hAnalysisHybFilter->bufferHFReal[k],
+                    (hAnalysisHybFilter->nrBands - setup->nrQmfBands),
+                    scalingValue);
+        scaleValues(hAnalysisHybFilter->bufferHFImag[k],
+                    (hAnalysisHybFilter->cplxBands - setup->nrQmfBands),
+                    scalingValue);
+      }
+    }
+  }
+  return err;
+}
+
+INT FDKhybridAnalysisApply(HANDLE_FDK_ANA_HYB_FILTER hAnalysisHybFilter,
+                           const FIXP_DBL *const pQmfReal,
+                           const FIXP_DBL *const pQmfImag,
+                           FIXP_DBL *const pHybridReal,
+                           FIXP_DBL *const pHybridImag) {
+  int k, hybOffset = 0;
+  INT err = 0;
+  const int nrQmfBandsLF =
+      hAnalysisHybFilter->pSetup
+          ->nrQmfBands; /* number of QMF bands to be converted to hybrid */
+
+  const int writIndex = hAnalysisHybFilter->bufferLFpos;
+  int readIndex = hAnalysisHybFilter->bufferLFpos;
+
+  if (++readIndex >= hAnalysisHybFilter->pSetup->protoLen) readIndex = 0;
+  const INT *pBufferLFreadIdx =
+      &hAnalysisHybFilter->pSetup->pReadIdxTable[readIndex];
+
+  /*
+   * LF buffer.
+   */
+  for (k = 0; k < nrQmfBandsLF; k++) {
+    /* New input sample. */
+    hAnalysisHybFilter->bufferLFReal[k][writIndex] = pQmfReal[k];
+    hAnalysisHybFilter->bufferLFImag[k][writIndex] = pQmfImag[k];
+
+    /* Perform hybrid filtering. */
+    err |=
+        kChannelFiltering(hAnalysisHybFilter->bufferLFReal[k],
+                          hAnalysisHybFilter->bufferLFImag[k], pBufferLFreadIdx,
+                          pHybridReal + hybOffset, pHybridImag + hybOffset,
+                          hAnalysisHybFilter->pSetup->kHybrid[k]);
+
+    hybOffset += hAnalysisHybFilter->pSetup->nHybBands[k];
+  }
+
+  hAnalysisHybFilter->bufferLFpos =
+      readIndex; /* Index where to write next input sample. */
+
+  if (hAnalysisHybFilter->nrBands > nrQmfBandsLF) {
+    /*
+     * HF buffer.
+     */
+    if (hAnalysisHybFilter->hfMode != 0) {
+      /* HF delay compensation was applied outside. */
+      FDKmemcpy(
+          pHybridReal + hybOffset, &pQmfReal[nrQmfBandsLF],
+          (hAnalysisHybFilter->nrBands - nrQmfBandsLF) * sizeof(FIXP_DBL));
+      FDKmemcpy(
+          pHybridImag + hybOffset, &pQmfImag[nrQmfBandsLF],
+          (hAnalysisHybFilter->cplxBands - nrQmfBandsLF) * sizeof(FIXP_DBL));
+    } else {
+      FDK_ASSERT(hAnalysisHybFilter->HFmemorySize != 0);
+      /* HF delay compensation, filterlength/2. */
+      FDKmemcpy(
+          pHybridReal + hybOffset,
+          hAnalysisHybFilter->bufferHFReal[hAnalysisHybFilter->bufferHFpos],
+          (hAnalysisHybFilter->nrBands - nrQmfBandsLF) * sizeof(FIXP_DBL));
+      FDKmemcpy(
+          pHybridImag + hybOffset,
+          hAnalysisHybFilter->bufferHFImag[hAnalysisHybFilter->bufferHFpos],
+          (hAnalysisHybFilter->cplxBands - nrQmfBandsLF) * sizeof(FIXP_DBL));
+
+      FDKmemcpy(
+          hAnalysisHybFilter->bufferHFReal[hAnalysisHybFilter->bufferHFpos],
+          &pQmfReal[nrQmfBandsLF],
+          (hAnalysisHybFilter->nrBands - nrQmfBandsLF) * sizeof(FIXP_DBL));
+      FDKmemcpy(
+          hAnalysisHybFilter->bufferHFImag[hAnalysisHybFilter->bufferHFpos],
+          &pQmfImag[nrQmfBandsLF],
+          (hAnalysisHybFilter->cplxBands - nrQmfBandsLF) * sizeof(FIXP_DBL));
+
+      if (++hAnalysisHybFilter->bufferHFpos >=
+          hAnalysisHybFilter->pSetup->filterDelay)
+        hAnalysisHybFilter->bufferHFpos = 0;
+    }
+  } /* process HF part*/
+
+  return err;
+}
+
+INT FDKhybridAnalysisClose(HANDLE_FDK_ANA_HYB_FILTER hAnalysisHybFilter) {
+  INT err = 0;
+
+  if (hAnalysisHybFilter != NULL) {
+    hAnalysisHybFilter->pLFmemory = NULL;
+    hAnalysisHybFilter->pHFmemory = NULL;
+    hAnalysisHybFilter->LFmemorySize = 0;
+    hAnalysisHybFilter->HFmemorySize = 0;
+  }
+
+  return err;
+}
+
+INT FDKhybridSynthesisInit(HANDLE_FDK_SYN_HYB_FILTER hSynthesisHybFilter,
+                           const FDK_HYBRID_MODE mode, const INT qmfBands,
+                           const INT cplxBands) {
+  INT err = 0;
+  HANDLE_FDK_HYBRID_SETUP setup = NULL;
+
+  switch (mode) {
+    case THREE_TO_TEN:
+      setup = &setup_3_10;
+      break;
+    case THREE_TO_TWELVE:
+      setup = &setup_3_12;
+      break;
+    case THREE_TO_SIXTEEN:
+      setup = &setup_3_16;
+      break;
+    default:
+      err = -1;
+      goto bail;
+  }
+
+  hSynthesisHybFilter->pSetup = setup;
+  hSynthesisHybFilter->nrBands = qmfBands;
+  hSynthesisHybFilter->cplxBands = cplxBands;
+
+bail:
+  return err;
+}
+
+void FDKhybridSynthesisApply(HANDLE_FDK_SYN_HYB_FILTER hSynthesisHybFilter,
+                             const FIXP_DBL *const pHybridReal,
+                             const FIXP_DBL *const pHybridImag,
+                             FIXP_DBL *const pQmfReal,
+                             FIXP_DBL *const pQmfImag) {
+  int k, n, hybOffset = 0;
+  const INT nrQmfBandsLF = hSynthesisHybFilter->pSetup->nrQmfBands;
+
+  /*
+   * LF buffer.
+   */
+  for (k = 0; k < nrQmfBandsLF; k++) {
+    const int nHybBands = hSynthesisHybFilter->pSetup->nHybBands[k];
+
+    FIXP_DBL accu1 = FL2FXCONST_DBL(0.f);
+    FIXP_DBL accu2 = FL2FXCONST_DBL(0.f);
+
+    /* Perform hybrid filtering. */
+    for (n = 0; n < nHybBands; n++) {
+      accu1 += pHybridReal[hybOffset + n];
+      accu2 += pHybridImag[hybOffset + n];
+    }
+    pQmfReal[k] = accu1;
+    pQmfImag[k] = accu2;
+
+    hybOffset += nHybBands;
+  }
+
+  if (hSynthesisHybFilter->nrBands > nrQmfBandsLF) {
+    /*
+     * HF buffer.
+     */
+    FDKmemcpy(&pQmfReal[nrQmfBandsLF], &pHybridReal[hybOffset],
+              (hSynthesisHybFilter->nrBands - nrQmfBandsLF) * sizeof(FIXP_DBL));
+    FDKmemcpy(
+        &pQmfImag[nrQmfBandsLF], &pHybridImag[hybOffset],
+        (hSynthesisHybFilter->cplxBands - nrQmfBandsLF) * sizeof(FIXP_DBL));
+  }
+
+  return;
+}
+
+static void dualChannelFiltering(const FIXP_DBL *const pQmfReal,
+                                 const FIXP_DBL *const pQmfImag,
+                                 const INT *const pReadIdx,
+                                 FIXP_DBL *const mHybridReal,
+                                 FIXP_DBL *const mHybridImag,
+                                 const INT invert) {
+  FIXP_DBL r1, r6;
+  FIXP_DBL i1, i6;
+
+  const FIXP_HTB f0 = HybFilterCoef2[0]; /* corresponds to p1 and p11 */
+  const FIXP_HTB f1 = HybFilterCoef2[1]; /* corresponds to p3 and p9  */
+  const FIXP_HTB f2 = HybFilterCoef2[2]; /* corresponds to p5 and p7  */
+
+  /* symmetric filter coefficients */
+  r1 = fMultDiv2(f0, pQmfReal[pReadIdx[1]]) +
+       fMultDiv2(f0, pQmfReal[pReadIdx[11]]);
+  i1 = fMultDiv2(f0, pQmfImag[pReadIdx[1]]) +
+       fMultDiv2(f0, pQmfImag[pReadIdx[11]]);
+  r1 += fMultDiv2(f1, pQmfReal[pReadIdx[3]]) +
+        fMultDiv2(f1, pQmfReal[pReadIdx[9]]);
+  i1 += fMultDiv2(f1, pQmfImag[pReadIdx[3]]) +
+        fMultDiv2(f1, pQmfImag[pReadIdx[9]]);
+  r1 += fMultDiv2(f2, pQmfReal[pReadIdx[5]]) +
+        fMultDiv2(f2, pQmfReal[pReadIdx[7]]);
+  i1 += fMultDiv2(f2, pQmfImag[pReadIdx[5]]) +
+        fMultDiv2(f2, pQmfImag[pReadIdx[7]]);
+
+  r6 = pQmfReal[pReadIdx[6]] >> 2;
+  i6 = pQmfImag[pReadIdx[6]] >> 2;
+
+  FDK_ASSERT((invert == 0) || (invert == 1));
+  mHybridReal[0 + invert] = (r6 + r1) << 1;
+  mHybridImag[0 + invert] = (i6 + i1) << 1;
+
+  mHybridReal[1 - invert] = (r6 - r1) << 1;
+  mHybridImag[1 - invert] = (i6 - i1) << 1;
+}
+
+static void fourChannelFiltering(const FIXP_DBL *const pQmfReal,
+                                 const FIXP_DBL *const pQmfImag,
+                                 const INT *const pReadIdx,
+                                 FIXP_DBL *const mHybridReal,
+                                 FIXP_DBL *const mHybridImag,
+                                 const INT invert) {
+  const FIXP_HTB *p = HybFilterCoef4;
+
+  FIXP_DBL fft[8];
+
+  static const FIXP_DBL cr[13] = {
+      FL2FXCONST_DBL(0.f),  FL2FXCONST_DBL(-0.70710678118655f),
+      FL2FXCONST_DBL(-1.f), FL2FXCONST_DBL(-0.70710678118655f),
+      FL2FXCONST_DBL(0.f),  FL2FXCONST_DBL(0.70710678118655f),
+      FL2FXCONST_DBL(1.f),  FL2FXCONST_DBL(0.70710678118655f),
+      FL2FXCONST_DBL(0.f),  FL2FXCONST_DBL(-0.70710678118655f),
+      FL2FXCONST_DBL(-1.f), FL2FXCONST_DBL(-0.70710678118655f),
+      FL2FXCONST_DBL(0.f)};
+  static const FIXP_DBL ci[13] = {
+      FL2FXCONST_DBL(-1.f), FL2FXCONST_DBL(-0.70710678118655f),
+      FL2FXCONST_DBL(0.f),  FL2FXCONST_DBL(0.70710678118655f),
+      FL2FXCONST_DBL(1.f),  FL2FXCONST_DBL(0.70710678118655f),
+      FL2FXCONST_DBL(0.f),  FL2FXCONST_DBL(-0.70710678118655f),
+      FL2FXCONST_DBL(-1.f), FL2FXCONST_DBL(-0.70710678118655f),
+      FL2FXCONST_DBL(0.f),  FL2FXCONST_DBL(0.70710678118655f),
+      FL2FXCONST_DBL(1.f)};
+
+  /* FIR filter. */
+  /* pre twiddeling with pre-twiddling coefficients c[n]  */
+  /* multiplication with filter coefficients p[n]         */
+  /* hint: (a + ib)*(c + id) = (a*c - b*d) + i(a*d + b*c) */
+  /* write to fft coefficient n'                          */
+  fft[FFT_IDX_R(0)] =
+      (fMult(p[10], (fMultSub(fMultDiv2(cr[2], pQmfReal[pReadIdx[2]]), ci[2],
+                              pQmfImag[pReadIdx[2]]))) +
+       fMult(p[6], (fMultSub(fMultDiv2(cr[6], pQmfReal[pReadIdx[6]]), ci[6],
+                             pQmfImag[pReadIdx[6]]))) +
+       fMult(p[2], (fMultSub(fMultDiv2(cr[10], pQmfReal[pReadIdx[10]]), ci[10],
+                             pQmfImag[pReadIdx[10]]))));
+  fft[FFT_IDX_I(0)] =
+      (fMult(p[10], (fMultAdd(fMultDiv2(ci[2], pQmfReal[pReadIdx[2]]), cr[2],
+                              pQmfImag[pReadIdx[2]]))) +
+       fMult(p[6], (fMultAdd(fMultDiv2(ci[6], pQmfReal[pReadIdx[6]]), cr[6],
+                             pQmfImag[pReadIdx[6]]))) +
+       fMult(p[2], (fMultAdd(fMultDiv2(ci[10], pQmfReal[pReadIdx[10]]), cr[10],
+                             pQmfImag[pReadIdx[10]]))));
+
+  /* twiddle dee dum */
+  fft[FFT_IDX_R(1)] =
+      (fMult(p[9], (fMultSub(fMultDiv2(cr[3], pQmfReal[pReadIdx[3]]), ci[3],
+                             pQmfImag[pReadIdx[3]]))) +
+       fMult(p[5], (fMultSub(fMultDiv2(cr[7], pQmfReal[pReadIdx[7]]), ci[7],
+                             pQmfImag[pReadIdx[7]]))) +
+       fMult(p[1], (fMultSub(fMultDiv2(cr[11], pQmfReal[pReadIdx[11]]), ci[11],
+                             pQmfImag[pReadIdx[11]]))));
+  fft[FFT_IDX_I(1)] =
+      (fMult(p[9], (fMultAdd(fMultDiv2(ci[3], pQmfReal[pReadIdx[3]]), cr[3],
+                             pQmfImag[pReadIdx[3]]))) +
+       fMult(p[5], (fMultAdd(fMultDiv2(ci[7], pQmfReal[pReadIdx[7]]), cr[7],
+                             pQmfImag[pReadIdx[7]]))) +
+       fMult(p[1], (fMultAdd(fMultDiv2(ci[11], pQmfReal[pReadIdx[11]]), cr[11],
+                             pQmfImag[pReadIdx[11]]))));
+
+  /* twiddle dee dee */
+  fft[FFT_IDX_R(2)] =
+      (fMult(p[12], (fMultSub(fMultDiv2(cr[0], pQmfReal[pReadIdx[0]]), ci[0],
+                              pQmfImag[pReadIdx[0]]))) +
+       fMult(p[8], (fMultSub(fMultDiv2(cr[4], pQmfReal[pReadIdx[4]]), ci[4],
+                             pQmfImag[pReadIdx[4]]))) +
+       fMult(p[4], (fMultSub(fMultDiv2(cr[8], pQmfReal[pReadIdx[8]]), ci[8],
+                             pQmfImag[pReadIdx[8]]))) +
+       fMult(p[0], (fMultSub(fMultDiv2(cr[12], pQmfReal[pReadIdx[12]]), ci[12],
+                             pQmfImag[pReadIdx[12]]))));
+  fft[FFT_IDX_I(2)] =
+      (fMult(p[12], (fMultAdd(fMultDiv2(ci[0], pQmfReal[pReadIdx[0]]), cr[0],
+                              pQmfImag[pReadIdx[0]]))) +
+       fMult(p[8], (fMultAdd(fMultDiv2(ci[4], pQmfReal[pReadIdx[4]]), cr[4],
+                             pQmfImag[pReadIdx[4]]))) +
+       fMult(p[4], (fMultAdd(fMultDiv2(ci[8], pQmfReal[pReadIdx[8]]), cr[8],
+                             pQmfImag[pReadIdx[8]]))) +
+       fMult(p[0], (fMultAdd(fMultDiv2(ci[12], pQmfReal[pReadIdx[12]]), cr[12],
+                             pQmfImag[pReadIdx[12]]))));
+
+  fft[FFT_IDX_R(3)] =
+      (fMult(p[11], (fMultSub(fMultDiv2(cr[1], pQmfReal[pReadIdx[1]]), ci[1],
+                              pQmfImag[pReadIdx[1]]))) +
+       fMult(p[7], (fMultSub(fMultDiv2(cr[5], pQmfReal[pReadIdx[5]]), ci[5],
+                             pQmfImag[pReadIdx[5]]))) +
+       fMult(p[3], (fMultSub(fMultDiv2(cr[9], pQmfReal[pReadIdx[9]]), ci[9],
+                             pQmfImag[pReadIdx[9]]))));
+  fft[FFT_IDX_I(3)] =
+      (fMult(p[11], (fMultAdd(fMultDiv2(ci[1], pQmfReal[pReadIdx[1]]), cr[1],
+                              pQmfImag[pReadIdx[1]]))) +
+       fMult(p[7], (fMultAdd(fMultDiv2(ci[5], pQmfReal[pReadIdx[5]]), cr[5],
+                             pQmfImag[pReadIdx[5]]))) +
+       fMult(p[3], (fMultAdd(fMultDiv2(ci[9], pQmfReal[pReadIdx[9]]), cr[9],
+                             pQmfImag[pReadIdx[9]]))));
+
+  /* fft modulation                                                    */
+  /* here: fast manual fft modulation for a fft of length M=4          */
+  /* fft_4{x[n]} = x[0]*exp(-i*2*pi/4*m*0) + x[1]*exp(-i*2*pi/4*m*1) +
+  x[2]*exp(-i*2*pi/4*m*2) + x[3]*exp(-i*2*pi/4*m*3)   */
+
+  /*
+  fft bin m=0:
+  X[0, n] = x[0] +   x[1] + x[2] +   x[3]
+  */
+  mHybridReal[0] = fft[FFT_IDX_R(0)] + fft[FFT_IDX_R(1)] + fft[FFT_IDX_R(2)] +
+                   fft[FFT_IDX_R(3)];
+  mHybridImag[0] = fft[FFT_IDX_I(0)] + fft[FFT_IDX_I(1)] + fft[FFT_IDX_I(2)] +
+                   fft[FFT_IDX_I(3)];
+
+  /*
+  fft bin m=1:
+  X[1, n] = x[0] - i*x[1] - x[2] + i*x[3]
+  */
+  mHybridReal[1] = fft[FFT_IDX_R(0)] + fft[FFT_IDX_I(1)] - fft[FFT_IDX_R(2)] -
+                   fft[FFT_IDX_I(3)];
+  mHybridImag[1] = fft[FFT_IDX_I(0)] - fft[FFT_IDX_R(1)] - fft[FFT_IDX_I(2)] +
+                   fft[FFT_IDX_R(3)];
+
+  /*
+  fft bin m=2:
+  X[2, n] = x[0] -   x[1] + x[2] -   x[3]
+  */
+  mHybridReal[2] = fft[FFT_IDX_R(0)] - fft[FFT_IDX_R(1)] + fft[FFT_IDX_R(2)] -
+                   fft[FFT_IDX_R(3)];
+  mHybridImag[2] = fft[FFT_IDX_I(0)] - fft[FFT_IDX_I(1)] + fft[FFT_IDX_I(2)] -
+                   fft[FFT_IDX_I(3)];
+
+  /*
+  fft bin m=3:
+  X[3, n] = x[0] + j*x[1] - x[2] - j*x[3]
+  */
+  mHybridReal[3] = fft[FFT_IDX_R(0)] - fft[FFT_IDX_I(1)] - fft[FFT_IDX_R(2)] +
+                   fft[FFT_IDX_I(3)];
+  mHybridImag[3] = fft[FFT_IDX_I(0)] + fft[FFT_IDX_R(1)] - fft[FFT_IDX_I(2)] -
+                   fft[FFT_IDX_R(3)];
+}
+
+static void eightChannelFiltering(const FIXP_DBL *const pQmfReal,
+                                  const FIXP_DBL *const pQmfImag,
+                                  const INT *const pReadIdx,
+                                  FIXP_DBL *const mHybridReal,
+                                  FIXP_DBL *const mHybridImag,
+                                  const INT invert) {
+  const FIXP_HTP *p = HybFilterCoef8;
+  INT k, sc;
+
+  FIXP_DBL mfft[16 + ALIGNMENT_DEFAULT];
+  FIXP_DBL *pfft = (FIXP_DBL *)ALIGN_PTR(mfft);
+
+  FIXP_DBL accu1, accu2, accu3, accu4;
+
+  /* pre twiddeling */
+  pfft[FFT_IDX_R(0)] =
+      pQmfReal[pReadIdx[6]] >>
+      (3 + 1); /* fMultDiv2(p[0].v.re, pQmfReal[pReadIdx[6]]); */
+  pfft[FFT_IDX_I(0)] =
+      pQmfImag[pReadIdx[6]] >>
+      (3 + 1); /* fMultDiv2(p[0].v.re, pQmfImag[pReadIdx[6]]); */
+
+  cplxMultDiv2(&accu1, &accu2, pQmfReal[pReadIdx[7]], pQmfImag[pReadIdx[7]],
+               p[1]);
+  pfft[FFT_IDX_R(1)] = accu1;
+  pfft[FFT_IDX_I(1)] = accu2;
+
+  cplxMultDiv2(&accu1, &accu2, pQmfReal[pReadIdx[0]], pQmfImag[pReadIdx[0]],
+               p[2]);
+  cplxMultDiv2(&accu3, &accu4, pQmfReal[pReadIdx[8]], pQmfImag[pReadIdx[8]],
+               p[3]);
+  pfft[FFT_IDX_R(2)] = accu1 + accu3;
+  pfft[FFT_IDX_I(2)] = accu2 + accu4;
+
+  cplxMultDiv2(&accu1, &accu2, pQmfReal[pReadIdx[1]], pQmfImag[pReadIdx[1]],
+               p[4]);
+  cplxMultDiv2(&accu3, &accu4, pQmfReal[pReadIdx[9]], pQmfImag[pReadIdx[9]],
+               p[5]);
+  pfft[FFT_IDX_R(3)] = accu1 + accu3;
+  pfft[FFT_IDX_I(3)] = accu2 + accu4;
+
+  pfft[FFT_IDX_R(4)] = fMultDiv2(pQmfImag[pReadIdx[10]], p[7].v.im) -
+                       fMultDiv2(pQmfImag[pReadIdx[2]], p[6].v.im);
+  pfft[FFT_IDX_I(4)] = fMultDiv2(pQmfReal[pReadIdx[2]], p[6].v.im) -
+                       fMultDiv2(pQmfReal[pReadIdx[10]], p[7].v.im);
+
+  cplxMultDiv2(&accu1, &accu2, pQmfReal[pReadIdx[3]], pQmfImag[pReadIdx[3]],
+               p[8]);
+  cplxMultDiv2(&accu3, &accu4, pQmfReal[pReadIdx[11]], pQmfImag[pReadIdx[11]],
+               p[9]);
+  pfft[FFT_IDX_R(5)] = accu1 + accu3;
+  pfft[FFT_IDX_I(5)] = accu2 + accu4;
+
+  cplxMultDiv2(&accu1, &accu2, pQmfReal[pReadIdx[4]], pQmfImag[pReadIdx[4]],
+               p[10]);
+  cplxMultDiv2(&accu3, &accu4, pQmfReal[pReadIdx[12]], pQmfImag[pReadIdx[12]],
+               p[11]);
+  pfft[FFT_IDX_R(6)] = accu1 + accu3;
+  pfft[FFT_IDX_I(6)] = accu2 + accu4;
+
+  cplxMultDiv2(&accu1, &accu2, pQmfReal[pReadIdx[5]], pQmfImag[pReadIdx[5]],
+               p[12]);
+  pfft[FFT_IDX_R(7)] = accu1;
+  pfft[FFT_IDX_I(7)] = accu2;
+
+  /* fft modulation */
+  fft_8(pfft);
+  sc = 1 + 2;
+
+  if (invert) {
+    mHybridReal[0] = pfft[FFT_IDX_R(7)] << sc;
+    mHybridImag[0] = pfft[FFT_IDX_I(7)] << sc;
+    mHybridReal[1] = pfft[FFT_IDX_R(0)] << sc;
+    mHybridImag[1] = pfft[FFT_IDX_I(0)] << sc;
+
+    mHybridReal[2] = pfft[FFT_IDX_R(6)] << sc;
+    mHybridImag[2] = pfft[FFT_IDX_I(6)] << sc;
+    mHybridReal[3] = pfft[FFT_IDX_R(1)] << sc;
+    mHybridImag[3] = pfft[FFT_IDX_I(1)] << sc;
+
+    mHybridReal[4] = pfft[FFT_IDX_R(2)] << sc;
+    mHybridReal[4] += pfft[FFT_IDX_R(5)] << sc;
+    mHybridImag[4] = pfft[FFT_IDX_I(2)] << sc;
+    mHybridImag[4] += pfft[FFT_IDX_I(5)] << sc;
+
+    mHybridReal[5] = pfft[FFT_IDX_R(3)] << sc;
+    mHybridReal[5] += pfft[FFT_IDX_R(4)] << sc;
+    mHybridImag[5] = pfft[FFT_IDX_I(3)] << sc;
+    mHybridImag[5] += pfft[FFT_IDX_I(4)] << sc;
+  } else {
+    for (k = 0; k < 8; k++) {
+      mHybridReal[k] = pfft[FFT_IDX_R(k)] << sc;
+      mHybridImag[k] = pfft[FFT_IDX_I(k)] << sc;
+    }
+  }
+}
+
+static INT kChannelFiltering(const FIXP_DBL *const pQmfReal,
+                             const FIXP_DBL *const pQmfImag,
+                             const INT *const pReadIdx,
+                             FIXP_DBL *const mHybridReal,
+                             FIXP_DBL *const mHybridImag,
+                             const SCHAR hybridConfig) {
+  INT err = 0;
+
+  switch (hybridConfig) {
+    case 2:
+    case -2:
+      dualChannelFiltering(pQmfReal, pQmfImag, pReadIdx, mHybridReal,
+                           mHybridImag, (hybridConfig < 0) ? 1 : 0);
+      break;
+    case 4:
+    case -4:
+      fourChannelFiltering(pQmfReal, pQmfImag, pReadIdx, mHybridReal,
+                           mHybridImag, (hybridConfig < 0) ? 1 : 0);
+      break;
+    case 8:
+    case -8:
+      eightChannelFiltering(pQmfReal, pQmfImag, pReadIdx, mHybridReal,
+                            mHybridImag, (hybridConfig < 0) ? 1 : 0);
+      break;
+    default:
+      err = -1;
+  }
+
+  return err;
+}