Merge GStreamer into next

1 files changed, 1135 insertions, 0 deletions

diff --git a/fdk-aac/libFDK/src/qmf.cpp b/fdk-aac/libFDK/src/qmf.cpp
new file mode 100644
index 0000000..6fca043
--- /dev/null
+++ b/fdk-aac/libFDK/src/qmf.cpp
@@ -0,0 +1,1135 @@
+/* -----------------------------------------------------------------------------
+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, Josef Hoepfl, Manuel Jander
+
+   Description: QMF filterbank
+
+*******************************************************************************/
+
+/*!
+  \file
+  \brief  Complex qmf analysis/synthesis
+  This module contains the qmf filterbank for analysis [
+  cplxAnalysisQmfFiltering() ] and synthesis [ cplxSynthesisQmfFiltering() ]. It
+  is a polyphase implementation of a complex exponential modulated filter bank.
+  The analysis part usually runs at half the sample rate than the synthesis
+  part. (So called "dual-rate" mode.)
+
+  The coefficients of the prototype filter are specified in #qmf_pfilt640 (in
+  sbr_rom.cpp). Thus only a 64 channel version (32 on the analysis side) with a
+  640 tap prototype filter are used.
+
+  \anchor PolyphaseFiltering <h2>About polyphase filtering</h2>
+  The polyphase implementation of a filterbank requires filtering at the input
+  and output. This is implemented as part of cplxAnalysisQmfFiltering() and
+  cplxSynthesisQmfFiltering(). The implementation requires the filter
+  coefficients in a specific structure as described in #sbr_qmf_64_640_qmf (in
+  sbr_rom.cpp).
+
+  This module comprises the computationally most expensive functions of the SBR
+  decoder. The accuracy of computations is also important and has a direct
+  impact on the overall sound quality. Therefore a special test program is
+  available which can be used to only test the filterbank: main_audio.cpp
+
+  This modules also uses scaling of data to provide better SNR on fixed-point
+  processors. See #QMF_SCALE_FACTOR (in sbr_scale.h) for details. An interesting
+  note: The function getScalefactor() can constitute a significant amount of
+  computational complexity - very much depending on the bitrate. Since it is a
+  rather small function, effective assembler optimization might be possible.
+
+*/
+
+#include "qmf.h"
+
+#include "FDK_trigFcts.h"
+#include "fixpoint_math.h"
+#include "dct.h"
+
+#define QSSCALE (0)
+#define FX_DBL2FX_QSS(x) (x)
+#define FX_QSS2FX_DBL(x) (x)
+
+/* moved to qmf_pcm.h: -> qmfSynPrototypeFirSlot */
+/* moved to qmf_pcm.h: -> qmfSynPrototypeFirSlot_NonSymmetric */
+/* moved to qmf_pcm.h: -> qmfSynthesisFilteringSlot */
+
+#ifndef FUNCTION_qmfAnaPrototypeFirSlot
+/*!
+  \brief Perform Analysis Prototype Filtering on a single slot of input data.
+*/
+static void qmfAnaPrototypeFirSlot(
+    FIXP_DBL *analysisBuffer,
+    INT no_channels, /*!< Number channels of analysis filter */
+    const FIXP_PFT *p_filter, INT p_stride, /*!< Stride of analysis filter    */
+    FIXP_QAS *RESTRICT pFilterStates) {
+  INT k;
+
+  FIXP_DBL accu;
+  const FIXP_PFT *RESTRICT p_flt = p_filter;
+  FIXP_DBL *RESTRICT pData_0 = analysisBuffer + 2 * no_channels - 1;
+  FIXP_DBL *RESTRICT pData_1 = analysisBuffer;
+
+  FIXP_QAS *RESTRICT sta_0 = (FIXP_QAS *)pFilterStates;
+  FIXP_QAS *RESTRICT sta_1 =
+      (FIXP_QAS *)pFilterStates + (2 * QMF_NO_POLY * no_channels) - 1;
+  INT pfltStep = QMF_NO_POLY * (p_stride);
+  INT staStep1 = no_channels << 1;
+  INT staStep2 = (no_channels << 3) - 1; /* Rewind one less */
+
+  /* FIR filters 127..64 0..63 */
+  for (k = 0; k < no_channels; k++) {
+    accu = fMultDiv2(p_flt[0], *sta_1);
+    sta_1 -= staStep1;
+    accu += fMultDiv2(p_flt[1], *sta_1);
+    sta_1 -= staStep1;
+    accu += fMultDiv2(p_flt[2], *sta_1);
+    sta_1 -= staStep1;
+    accu += fMultDiv2(p_flt[3], *sta_1);
+    sta_1 -= staStep1;
+    accu += fMultDiv2(p_flt[4], *sta_1);
+    *pData_1++ = (accu << 1);
+    sta_1 += staStep2;
+
+    p_flt += pfltStep;
+    accu = fMultDiv2(p_flt[0], *sta_0);
+    sta_0 += staStep1;
+    accu += fMultDiv2(p_flt[1], *sta_0);
+    sta_0 += staStep1;
+    accu += fMultDiv2(p_flt[2], *sta_0);
+    sta_0 += staStep1;
+    accu += fMultDiv2(p_flt[3], *sta_0);
+    sta_0 += staStep1;
+    accu += fMultDiv2(p_flt[4], *sta_0);
+    *pData_0-- = (accu << 1);
+    sta_0 -= staStep2;
+  }
+}
+#endif /* !defined(FUNCTION_qmfAnaPrototypeFirSlot) */
+
+#ifndef FUNCTION_qmfAnaPrototypeFirSlot_NonSymmetric
+/*!
+  \brief Perform Analysis Prototype Filtering on a single slot of input data.
+*/
+static void qmfAnaPrototypeFirSlot_NonSymmetric(
+    FIXP_DBL *analysisBuffer,
+    int no_channels, /*!< Number channels of analysis filter */
+    const FIXP_PFT *p_filter, int p_stride, /*!< Stride of analysis filter    */
+    FIXP_QAS *RESTRICT pFilterStates) {
+  const FIXP_PFT *RESTRICT p_flt = p_filter;
+  int p, k;
+
+  for (k = 0; k < 2 * no_channels; k++) {
+    FIXP_DBL accu = (FIXP_DBL)0;
+
+    p_flt += QMF_NO_POLY * (p_stride - 1);
+
+    /*
+      Perform FIR-Filter
+    */
+    for (p = 0; p < QMF_NO_POLY; p++) {
+      accu += fMultDiv2(*p_flt++, pFilterStates[2 * no_channels * p]);
+    }
+    analysisBuffer[2 * no_channels - 1 - k] = (accu << 1);
+    pFilterStates++;
+  }
+}
+#endif /* FUNCTION_qmfAnaPrototypeFirSlot_NonSymmetric */
+
+/*!
+ *
+ * \brief Perform real-valued forward modulation of the time domain
+ *        data of timeIn and stores the real part of the subband
+ *        samples in rSubband
+ *
+ */
+static void qmfForwardModulationLP_even(
+    HANDLE_QMF_FILTER_BANK anaQmf, /*!< Handle of Qmf Analysis Bank  */
+    FIXP_DBL *timeIn,              /*!< Time Signal */
+    FIXP_DBL *rSubband)            /*!< Real Output */
+{
+  int i;
+  int L = anaQmf->no_channels;
+  int M = L >> 1;
+  int scale;
+  FIXP_DBL accu;
+
+  const FIXP_DBL *timeInTmp1 = (FIXP_DBL *)&timeIn[3 * M];
+  const FIXP_DBL *timeInTmp2 = timeInTmp1;
+  FIXP_DBL *rSubbandTmp = rSubband;
+
+  rSubband[0] = timeIn[3 * M] >> 1;
+
+  for (i = M - 1; i != 0; i--) {
+    accu = ((*--timeInTmp1) >> 1) + ((*++timeInTmp2) >> 1);
+    *++rSubbandTmp = accu;
+  }
+
+  timeInTmp1 = &timeIn[2 * M];
+  timeInTmp2 = &timeIn[0];
+  rSubbandTmp = &rSubband[M];
+
+  for (i = L - M; i != 0; i--) {
+    accu = ((*timeInTmp1--) >> 1) - ((*timeInTmp2++) >> 1);
+    *rSubbandTmp++ = accu;
+  }
+
+  dct_III(rSubband, timeIn, L, &scale);
+}
+
+#if !defined(FUNCTION_qmfForwardModulationLP_odd)
+static void qmfForwardModulationLP_odd(
+    HANDLE_QMF_FILTER_BANK anaQmf, /*!< Handle of Qmf Analysis Bank  */
+    const FIXP_DBL *timeIn,        /*!< Time Signal */
+    FIXP_DBL *rSubband)            /*!< Real Output */
+{
+  int i;
+  int L = anaQmf->no_channels;
+  int M = L >> 1;
+  int shift = (anaQmf->no_channels >> 6) + 1;
+
+  for (i = 0; i < M; i++) {
+    rSubband[M + i] = (timeIn[L - 1 - i] >> 1) - (timeIn[i] >> shift);
+    rSubband[M - 1 - i] =
+        (timeIn[L + i] >> 1) + (timeIn[2 * L - 1 - i] >> shift);
+  }
+
+  dct_IV(rSubband, L, &shift);
+}
+#endif /* !defined(FUNCTION_qmfForwardModulationLP_odd) */
+
+/*!
+ *
+ * \brief Perform complex-valued forward modulation of the time domain
+ *        data of timeIn and stores the real part of the subband
+ *        samples in rSubband, and the imaginary part in iSubband
+ *
+ *
+ */
+#if !defined(FUNCTION_qmfForwardModulationHQ)
+static void qmfForwardModulationHQ(
+    HANDLE_QMF_FILTER_BANK anaQmf,   /*!< Handle of Qmf Analysis Bank  */
+    const FIXP_DBL *RESTRICT timeIn, /*!< Time Signal */
+    FIXP_DBL *RESTRICT rSubband,     /*!< Real Output */
+    FIXP_DBL *RESTRICT iSubband      /*!< Imaginary Output */
+) {
+  int i;
+  int L = anaQmf->no_channels;
+  int L2 = L << 1;
+  int shift = 0;
+
+  /* Time advance by one sample, which is equivalent to the complex
+     rotation at the end of the analysis. Works only for STD mode. */
+  if ((L == 64) && !(anaQmf->flags & (QMF_FLAG_CLDFB | QMF_FLAG_MPSLDFB))) {
+    FIXP_DBL x, y;
+
+    /*rSubband[0] = u[1] + u[0]*/
+    /*iSubband[0] = u[1] - u[0]*/
+    x = timeIn[1] >> 1;
+    y = timeIn[0];
+    rSubband[0] = x + (y >> 1);
+    iSubband[0] = x - (y >> 1);
+
+    /*rSubband[n] = u[n+1] - u[2M-n], n=1,...,M-1*/
+    /*iSubband[n] = u[n+1] + u[2M-n], n=1,...,M-1*/
+    for (i = 1; i < L; i++) {
+      x = timeIn[i + 1] >> 1; /*u[n+1]  */
+      y = timeIn[L2 - i];     /*u[2M-n] */
+      rSubband[i] = x - (y >> 1);
+      iSubband[i] = x + (y >> 1);
+    }
+  } else {
+    for (i = 0; i < L; i += 2) {
+      FIXP_DBL x0, x1, y0, y1;
+
+      x0 = timeIn[i + 0] >> 1;
+      x1 = timeIn[i + 1] >> 1;
+      y0 = timeIn[L2 - 1 - i];
+      y1 = timeIn[L2 - 2 - i];
+
+      rSubband[i + 0] = x0 - (y0 >> 1);
+      rSubband[i + 1] = x1 - (y1 >> 1);
+      iSubband[i + 0] = x0 + (y0 >> 1);
+      iSubband[i + 1] = x1 + (y1 >> 1);
+    }
+  }
+
+  dct_IV(rSubband, L, &shift);
+  dst_IV(iSubband, L, &shift);
+
+  /* Do the complex rotation except for the case of 64 bands (in STD mode). */
+  if ((L != 64) || (anaQmf->flags & (QMF_FLAG_CLDFB | QMF_FLAG_MPSLDFB))) {
+    if (anaQmf->flags & QMF_FLAG_MPSLDFB_OPTIMIZE_MODULATION) {
+      FIXP_DBL iBand;
+      for (i = 0; i < fMin(anaQmf->lsb, L); i += 2) {
+        iBand = rSubband[i];
+        rSubband[i] = -iSubband[i];
+        iSubband[i] = iBand;
+
+        iBand = -rSubband[i + 1];
+        rSubband[i + 1] = iSubband[i + 1];
+        iSubband[i + 1] = iBand;
+      }
+    } else {
+      const FIXP_QTW *sbr_t_cos;
+      const FIXP_QTW *sbr_t_sin;
+      const int len = L; /* was len = fMin(anaQmf->lsb, L) but in case of USAC
+                            the signal above lsb is actually needed in some
+                            cases (HBE?) */
+      sbr_t_cos = anaQmf->t_cos;
+      sbr_t_sin = anaQmf->t_sin;
+
+      for (i = 0; i < len; i++) {
+        cplxMult(&iSubband[i], &rSubband[i], iSubband[i], rSubband[i],
+                 sbr_t_cos[i], sbr_t_sin[i]);
+      }
+    }
+  }
+}
+#endif /* FUNCTION_qmfForwardModulationHQ */
+
+/*
+ * \brief Perform one QMF slot analysis of the time domain data of timeIn
+ *        with specified stride and stores the real part of the subband
+ *        samples in rSubband, and the imaginary part in iSubband
+ *
+ *        Note: anaQmf->lsb can be greater than anaQmf->no_channels in case
+ *        of implicit resampling (USAC with reduced 3/4 core frame length).
+ */
+#if (SAMPLE_BITS != DFRACT_BITS) && (QAS_BITS == DFRACT_BITS)
+void qmfAnalysisFilteringSlot(
+    HANDLE_QMF_FILTER_BANK anaQmf, /*!< Handle of Qmf Synthesis Bank  */
+    FIXP_DBL *qmfReal,             /*!< Low and High band, real */
+    FIXP_DBL *qmfImag,             /*!< Low and High band, imag */
+    const LONG *RESTRICT timeIn,   /*!< Pointer to input */
+    const int stride,              /*!< stride factor of input */
+    FIXP_DBL *pWorkBuffer          /*!< pointer to temporal working buffer */
+) {
+  int offset = anaQmf->no_channels * (QMF_NO_POLY * 2 - 1);
+  /*
+    Feed time signal into oldest anaQmf->no_channels states
+  */
+  {
+    FIXP_DBL *FilterStatesAnaTmp = ((FIXP_DBL *)anaQmf->FilterStates) + offset;
+
+    /* Feed and scale actual time in slot */
+    for (int i = anaQmf->no_channels >> 1; i != 0; i--) {
+      /* Place INT_PCM value left aligned in scaledTimeIn */
+
+      *FilterStatesAnaTmp++ = (FIXP_QAS)*timeIn;
+      timeIn += stride;
+      *FilterStatesAnaTmp++ = (FIXP_QAS)*timeIn;
+      timeIn += stride;
+    }
+  }
+
+  if (anaQmf->flags & QMF_FLAG_NONSYMMETRIC) {
+    qmfAnaPrototypeFirSlot_NonSymmetric(pWorkBuffer, anaQmf->no_channels,
+                                        anaQmf->p_filter, anaQmf->p_stride,
+                                        (FIXP_QAS *)anaQmf->FilterStates);
+  } else {
+    qmfAnaPrototypeFirSlot(pWorkBuffer, anaQmf->no_channels, anaQmf->p_filter,
+                           anaQmf->p_stride, (FIXP_QAS *)anaQmf->FilterStates);
+  }
+
+  if (anaQmf->flags & QMF_FLAG_LP) {
+    if (anaQmf->flags & QMF_FLAG_CLDFB)
+      qmfForwardModulationLP_odd(anaQmf, pWorkBuffer, qmfReal);
+    else
+      qmfForwardModulationLP_even(anaQmf, pWorkBuffer, qmfReal);
+
+  } else {
+    qmfForwardModulationHQ(anaQmf, pWorkBuffer, qmfReal, qmfImag);
+  }
+  /*
+    Shift filter states
+
+    Should be realized with modulo adressing on a DSP instead of a true buffer
+    shift
+  */
+  FDKmemmove(anaQmf->FilterStates,
+             (FIXP_QAS *)anaQmf->FilterStates + anaQmf->no_channels,
+             offset * sizeof(FIXP_QAS));
+}
+#endif
+
+void qmfAnalysisFilteringSlot(
+    HANDLE_QMF_FILTER_BANK anaQmf,  /*!< Handle of Qmf Synthesis Bank  */
+    FIXP_DBL *qmfReal,              /*!< Low and High band, real */
+    FIXP_DBL *qmfImag,              /*!< Low and High band, imag */
+    const INT_PCM *RESTRICT timeIn, /*!< Pointer to input */
+    const int stride,               /*!< stride factor of input */
+    FIXP_DBL *pWorkBuffer           /*!< pointer to temporal working buffer */
+) {
+  int offset = anaQmf->no_channels * (QMF_NO_POLY * 2 - 1);
+  /*
+    Feed time signal into oldest anaQmf->no_channels states
+  */
+  {
+    FIXP_QAS *FilterStatesAnaTmp = ((FIXP_QAS *)anaQmf->FilterStates) + offset;
+
+    /* Feed and scale actual time in slot */
+    for (int i = anaQmf->no_channels >> 1; i != 0; i--) {
+    /* Place INT_PCM value left aligned in scaledTimeIn */
+#if (QAS_BITS == SAMPLE_BITS)
+      *FilterStatesAnaTmp++ = (FIXP_QAS)*timeIn;
+      timeIn += stride;
+      *FilterStatesAnaTmp++ = (FIXP_QAS)*timeIn;
+      timeIn += stride;
+#elif (QAS_BITS > SAMPLE_BITS)
+      *FilterStatesAnaTmp++ = ((FIXP_QAS)*timeIn) << (QAS_BITS - SAMPLE_BITS);
+      timeIn += stride;
+      *FilterStatesAnaTmp++ = ((FIXP_QAS)*timeIn) << (QAS_BITS - SAMPLE_BITS);
+      timeIn += stride;
+#else
+      *FilterStatesAnaTmp++ = (FIXP_QAS)((*timeIn) >> (SAMPLE_BITS - QAS_BITS));
+      timeIn += stride;
+      *FilterStatesAnaTmp++ = (FIXP_QAS)((*timeIn) >> (SAMPLE_BITS - QAS_BITS));
+      timeIn += stride;
+#endif
+    }
+  }
+
+  if (anaQmf->flags & QMF_FLAG_NONSYMMETRIC) {
+    qmfAnaPrototypeFirSlot_NonSymmetric(pWorkBuffer, anaQmf->no_channels,
+                                        anaQmf->p_filter, anaQmf->p_stride,
+                                        (FIXP_QAS *)anaQmf->FilterStates);
+  } else {
+    qmfAnaPrototypeFirSlot(pWorkBuffer, anaQmf->no_channels, anaQmf->p_filter,
+                           anaQmf->p_stride, (FIXP_QAS *)anaQmf->FilterStates);
+  }
+
+  if (anaQmf->flags & QMF_FLAG_LP) {
+    if (anaQmf->flags & QMF_FLAG_CLDFB)
+      qmfForwardModulationLP_odd(anaQmf, pWorkBuffer, qmfReal);
+    else
+      qmfForwardModulationLP_even(anaQmf, pWorkBuffer, qmfReal);
+
+  } else {
+    qmfForwardModulationHQ(anaQmf, pWorkBuffer, qmfReal, qmfImag);
+  }
+  /*
+    Shift filter states
+
+    Should be realized with modulo adressing on a DSP instead of a true buffer
+    shift
+  */
+  FDKmemmove(anaQmf->FilterStates,
+             (FIXP_QAS *)anaQmf->FilterStates + anaQmf->no_channels,
+             offset * sizeof(FIXP_QAS));
+}
+
+/*!
+ *
+ * \brief Perform complex-valued subband filtering of the time domain
+ *        data of timeIn and stores the real part of the subband
+ *        samples in rAnalysis, and the imaginary part in iAnalysis
+ * The qmf coefficient table is symmetric. The symmetry is expoited by
+ * shrinking the coefficient table to half the size. The addressing mode
+ * takes care of the symmetries.
+ *
+ *
+ * \sa PolyphaseFiltering
+ */
+#if (SAMPLE_BITS != DFRACT_BITS) && (QAS_BITS == DFRACT_BITS)
+void qmfAnalysisFiltering(
+    HANDLE_QMF_FILTER_BANK anaQmf, /*!< Handle of Qmf Analysis Bank */
+    FIXP_DBL **qmfReal,            /*!< Pointer to real subband slots */
+    FIXP_DBL **qmfImag,            /*!< Pointer to imag subband slots */
+    QMF_SCALE_FACTOR *scaleFactor, const LONG *timeIn, /*!< Time signal */
+    const int timeIn_e, const int stride,
+    FIXP_DBL *pWorkBuffer /*!< pointer to temporal working buffer */
+) {
+  int i;
+  int no_channels = anaQmf->no_channels;
+
+  scaleFactor->lb_scale =
+      -ALGORITHMIC_SCALING_IN_ANALYSIS_FILTERBANK - timeIn_e;
+  scaleFactor->lb_scale -= anaQmf->filterScale;
+
+  for (i = 0; i < anaQmf->no_col; i++) {
+    FIXP_DBL *qmfImagSlot = NULL;
+
+    if (!(anaQmf->flags & QMF_FLAG_LP)) {
+      qmfImagSlot = qmfImag[i];
+    }
+
+    qmfAnalysisFilteringSlot(anaQmf, qmfReal[i], qmfImagSlot, timeIn, stride,
+                             pWorkBuffer);
+
+    timeIn += no_channels * stride;
+
+  } /* no_col loop  i  */
+}
+#endif
+
+void qmfAnalysisFiltering(
+    HANDLE_QMF_FILTER_BANK anaQmf, /*!< Handle of Qmf Analysis Bank */
+    FIXP_DBL **qmfReal,            /*!< Pointer to real subband slots */
+    FIXP_DBL **qmfImag,            /*!< Pointer to imag subband slots */
+    QMF_SCALE_FACTOR *scaleFactor, const INT_PCM *timeIn, /*!< Time signal */
+    const int timeIn_e, const int stride,
+    FIXP_DBL *pWorkBuffer /*!< pointer to temporal working buffer */
+) {
+  int i;
+  int no_channels = anaQmf->no_channels;
+
+  scaleFactor->lb_scale =
+      -ALGORITHMIC_SCALING_IN_ANALYSIS_FILTERBANK - timeIn_e;
+  scaleFactor->lb_scale -= anaQmf->filterScale;
+
+  for (i = 0; i < anaQmf->no_col; i++) {
+    FIXP_DBL *qmfImagSlot = NULL;
+
+    if (!(anaQmf->flags & QMF_FLAG_LP)) {
+      qmfImagSlot = qmfImag[i];
+    }
+
+    qmfAnalysisFilteringSlot(anaQmf, qmfReal[i], qmfImagSlot, timeIn, stride,
+                             pWorkBuffer);
+
+    timeIn += no_channels * stride;
+
+  } /* no_col loop  i  */
+}
+
+/*!
+ *
+ * \brief Perform low power inverse modulation of the subband
+ *        samples stored in rSubband (real part) and iSubband (imaginary
+ *        part) and stores the result in pWorkBuffer.
+ *
+ */
+inline static void qmfInverseModulationLP_even(
+    HANDLE_QMF_FILTER_BANK synQmf, /*!< Handle of Qmf Synthesis Bank  */
+    const FIXP_DBL *qmfReal, /*!< Pointer to qmf real subband slot (input) */
+    const int scaleFactorLowBand,  /*!< Scalefactor for Low band */
+    const int scaleFactorHighBand, /*!< Scalefactor for High band */
+    FIXP_DBL *pTimeOut             /*!< Pointer to qmf subband slot (output)*/
+) {
+  int i;
+  int L = synQmf->no_channels;
+  int M = L >> 1;
+  int scale;
+  FIXP_DBL tmp;
+  FIXP_DBL *RESTRICT tReal = pTimeOut;
+  FIXP_DBL *RESTRICT tImag = pTimeOut + L;
+
+  /* Move input to output vector with offset */
+  scaleValues(&tReal[0], &qmfReal[0], synQmf->lsb, (int)scaleFactorLowBand);
+  scaleValues(&tReal[0 + synQmf->lsb], &qmfReal[0 + synQmf->lsb],
+              synQmf->usb - synQmf->lsb, (int)scaleFactorHighBand);
+  FDKmemclear(&tReal[0 + synQmf->usb], (L - synQmf->usb) * sizeof(FIXP_DBL));
+
+  /* Dct type-2 transform */
+  dct_II(tReal, tImag, L, &scale);
+
+  /* Expand output and replace inplace the output buffers */
+  tImag[0] = tReal[M];
+  tImag[M] = (FIXP_DBL)0;
+  tmp = tReal[0];
+  tReal[0] = tReal[M];
+  tReal[M] = tmp;
+
+  for (i = 1; i < M / 2; i++) {
+    /* Imag */
+    tmp = tReal[L - i];
+    tImag[M - i] = tmp;
+    tImag[i + M] = -tmp;
+
+    tmp = tReal[M + i];
+    tImag[i] = tmp;
+    tImag[L - i] = -tmp;
+
+    /* Real */
+    tReal[M + i] = tReal[i];
+    tReal[L - i] = tReal[M - i];
+    tmp = tReal[i];
+    tReal[i] = tReal[M - i];
+    tReal[M - i] = tmp;
+  }
+  /* Remaining odd terms */
+  tmp = tReal[M + M / 2];
+  tImag[M / 2] = tmp;
+  tImag[M / 2 + M] = -tmp;
+
+  tReal[M + M / 2] = tReal[M / 2];
+}
+
+inline static void qmfInverseModulationLP_odd(
+    HANDLE_QMF_FILTER_BANK synQmf, /*!< Handle of Qmf Synthesis Bank  */
+    const FIXP_DBL *qmfReal, /*!< Pointer to qmf real subband slot (input) */
+    const int scaleFactorLowBand,  /*!< Scalefactor for Low band */
+    const int scaleFactorHighBand, /*!< Scalefactor for High band */
+    FIXP_DBL *pTimeOut             /*!< Pointer to qmf subband slot (output)*/
+) {
+  int i;
+  int L = synQmf->no_channels;
+  int M = L >> 1;
+  int shift = 0;
+
+  /* Move input to output vector with offset */
+  scaleValues(pTimeOut + M, qmfReal, synQmf->lsb, scaleFactorLowBand);
+  scaleValues(pTimeOut + M + synQmf->lsb, qmfReal + synQmf->lsb,
+              synQmf->usb - synQmf->lsb, scaleFactorHighBand);
+  FDKmemclear(pTimeOut + M + synQmf->usb, (L - synQmf->usb) * sizeof(FIXP_DBL));
+
+  dct_IV(pTimeOut + M, L, &shift);
+  for (i = 0; i < M; i++) {
+    pTimeOut[i] = pTimeOut[L - 1 - i];
+    pTimeOut[2 * L - 1 - i] = -pTimeOut[L + i];
+  }
+}
+
+#ifndef FUNCTION_qmfInverseModulationHQ
+/*!
+ *
+ * \brief Perform complex-valued inverse modulation of the subband
+ *        samples stored in rSubband (real part) and iSubband (imaginary
+ *        part) and stores the result in pWorkBuffer.
+ *
+ */
+inline static void qmfInverseModulationHQ(
+    HANDLE_QMF_FILTER_BANK synQmf, /*!< Handle of Qmf Synthesis Bank     */
+    const FIXP_DBL *qmfReal,       /*!< Pointer to qmf real subband slot */
+    const FIXP_DBL *qmfImag,       /*!< Pointer to qmf imag subband slot */
+    const int scaleFactorLowBand,  /*!< Scalefactor for Low band         */
+    const int scaleFactorHighBand, /*!< Scalefactor for High band        */
+    FIXP_DBL *pWorkBuffer          /*!< WorkBuffer (output)              */
+) {
+  int i;
+  int L = synQmf->no_channels;
+  int M = L >> 1;
+  int shift = 0;
+  FIXP_DBL *RESTRICT tReal = pWorkBuffer;
+  FIXP_DBL *RESTRICT tImag = pWorkBuffer + L;
+
+  if (synQmf->flags & QMF_FLAG_CLDFB) {
+    for (i = 0; i < synQmf->lsb; i++) {
+      cplxMult(&tImag[i], &tReal[i], scaleValue(qmfImag[i], scaleFactorLowBand),
+               scaleValue(qmfReal[i], scaleFactorLowBand), synQmf->t_cos[i],
+               synQmf->t_sin[i]);
+    }
+    for (; i < synQmf->usb; i++) {
+      cplxMult(&tImag[i], &tReal[i],
+               scaleValue(qmfImag[i], scaleFactorHighBand),
+               scaleValue(qmfReal[i], scaleFactorHighBand), synQmf->t_cos[i],
+               synQmf->t_sin[i]);
+    }
+  }
+
+  if ((synQmf->flags & QMF_FLAG_CLDFB) == 0) {
+    scaleValues(&tReal[0], &qmfReal[0], synQmf->lsb, (int)scaleFactorLowBand);
+    scaleValues(&tReal[0 + synQmf->lsb], &qmfReal[0 + synQmf->lsb],
+                synQmf->usb - synQmf->lsb, (int)scaleFactorHighBand);
+    scaleValues(&tImag[0], &qmfImag[0], synQmf->lsb, (int)scaleFactorLowBand);
+    scaleValues(&tImag[0 + synQmf->lsb], &qmfImag[0 + synQmf->lsb],
+                synQmf->usb - synQmf->lsb, (int)scaleFactorHighBand);
+  }
+
+  FDKmemclear(&tReal[synQmf->usb],
+              (synQmf->no_channels - synQmf->usb) * sizeof(FIXP_DBL));
+  FDKmemclear(&tImag[synQmf->usb],
+              (synQmf->no_channels - synQmf->usb) * sizeof(FIXP_DBL));
+
+  dct_IV(tReal, L, &shift);
+  dst_IV(tImag, L, &shift);
+
+  if (synQmf->flags & QMF_FLAG_CLDFB) {
+    for (i = 0; i < M; i++) {
+      FIXP_DBL r1, i1, r2, i2;
+      r1 = tReal[i];
+      i2 = tImag[L - 1 - i];
+      r2 = tReal[L - i - 1];
+      i1 = tImag[i];
+
+      tReal[i] = (r1 - i1) >> 1;
+      tImag[L - 1 - i] = -(r1 + i1) >> 1;
+      tReal[L - i - 1] = (r2 - i2) >> 1;
+      tImag[i] = -(r2 + i2) >> 1;
+    }
+  } else {
+    /* The array accesses are negative to compensate the missing minus sign in
+     * the low and hi band gain. */
+    /* 26 cycles on ARM926 */
+    for (i = 0; i < M; i++) {
+      FIXP_DBL r1, i1, r2, i2;
+      r1 = -tReal[i];
+      i2 = -tImag[L - 1 - i];
+      r2 = -tReal[L - i - 1];
+      i1 = -tImag[i];
+
+      tReal[i] = (r1 - i1) >> 1;
+      tImag[L - 1 - i] = -(r1 + i1) >> 1;
+      tReal[L - i - 1] = (r2 - i2) >> 1;
+      tImag[i] = -(r2 + i2) >> 1;
+    }
+  }
+}
+#endif /* #ifndef FUNCTION_qmfInverseModulationHQ */
+
+/*!
+ *
+ * \brief Create QMF filter bank instance
+ *
+ * \return 0 if successful
+ *
+ */
+static int qmfInitFilterBank(
+    HANDLE_QMF_FILTER_BANK h_Qmf, /*!< Handle to return */
+    void *pFilterStates,          /*!< Handle to filter states */
+    int noCols,                   /*!< Number of timeslots per frame */
+    int lsb,                      /*!< Lower end of QMF frequency range */
+    int usb,                      /*!< Upper end of QMF frequency range */
+    int no_channels,              /*!< Number of channels (bands) */
+    UINT flags,                   /*!< flags */
+    int synflag)                  /*!< 1: synthesis; 0: analysis */
+{
+  FDKmemclear(h_Qmf, sizeof(QMF_FILTER_BANK));
+
+  if (flags & QMF_FLAG_MPSLDFB) {
+    flags |= QMF_FLAG_NONSYMMETRIC;
+    flags |= QMF_FLAG_MPSLDFB_OPTIMIZE_MODULATION;
+
+    h_Qmf->t_cos = NULL;
+    h_Qmf->t_sin = NULL;
+    h_Qmf->filterScale = QMF_MPSLDFB_PFT_SCALE;
+    h_Qmf->p_stride = 1;
+
+    switch (no_channels) {
+      case 64:
+        h_Qmf->p_filter = qmf_mpsldfb_640;
+        h_Qmf->FilterSize = 640;
+        break;
+      case 32:
+        h_Qmf->p_filter = qmf_mpsldfb_320;
+        h_Qmf->FilterSize = 320;
+        break;
+      default:
+        return -1;
+    }
+  }
+
+  if (!(flags & QMF_FLAG_MPSLDFB) && (flags & QMF_FLAG_CLDFB)) {
+    flags |= QMF_FLAG_NONSYMMETRIC;
+    h_Qmf->filterScale = QMF_CLDFB_PFT_SCALE;
+
+    h_Qmf->p_stride = 1;
+    switch (no_channels) {
+      case 64:
+        h_Qmf->t_cos = qmf_phaseshift_cos64_cldfb;
+        h_Qmf->t_sin = qmf_phaseshift_sin64_cldfb;
+        h_Qmf->p_filter = qmf_cldfb_640;
+        h_Qmf->FilterSize = 640;
+        break;
+      case 32:
+        h_Qmf->t_cos = (synflag) ? qmf_phaseshift_cos32_cldfb_syn
+                                 : qmf_phaseshift_cos32_cldfb_ana;
+        h_Qmf->t_sin = qmf_phaseshift_sin32_cldfb;
+        h_Qmf->p_filter = qmf_cldfb_320;
+        h_Qmf->FilterSize = 320;
+        break;
+      case 16:
+        h_Qmf->t_cos = (synflag) ? qmf_phaseshift_cos16_cldfb_syn
+                                 : qmf_phaseshift_cos16_cldfb_ana;
+        h_Qmf->t_sin = qmf_phaseshift_sin16_cldfb;
+        h_Qmf->p_filter = qmf_cldfb_160;
+        h_Qmf->FilterSize = 160;
+        break;
+      case 8:
+        h_Qmf->t_cos = (synflag) ? qmf_phaseshift_cos8_cldfb_syn
+                                 : qmf_phaseshift_cos8_cldfb_ana;
+        h_Qmf->t_sin = qmf_phaseshift_sin8_cldfb;
+        h_Qmf->p_filter = qmf_cldfb_80;
+        h_Qmf->FilterSize = 80;
+        break;
+      default:
+        return -1;
+    }
+  }
+
+  if (!(flags & QMF_FLAG_MPSLDFB) && ((flags & QMF_FLAG_CLDFB) == 0)) {
+    switch (no_channels) {
+      case 64:
+        h_Qmf->p_filter = qmf_pfilt640;
+        h_Qmf->t_cos = qmf_phaseshift_cos64;
+        h_Qmf->t_sin = qmf_phaseshift_sin64;
+        h_Qmf->p_stride = 1;
+        h_Qmf->FilterSize = 640;
+        h_Qmf->filterScale = 0;
+        break;
+      case 40:
+        if (synflag) {
+          break;
+        } else {
+          h_Qmf->p_filter = qmf_pfilt400; /* Scaling factor 0.8 */
+          h_Qmf->t_cos = qmf_phaseshift_cos40;
+          h_Qmf->t_sin = qmf_phaseshift_sin40;
+          h_Qmf->filterScale = 1;
+          h_Qmf->p_stride = 1;
+          h_Qmf->FilterSize = no_channels * 10;
+        }
+        break;
+      case 32:
+        h_Qmf->p_filter = qmf_pfilt640;
+        if (flags & QMF_FLAG_DOWNSAMPLED) {
+          h_Qmf->t_cos = qmf_phaseshift_cos_downsamp32;
+          h_Qmf->t_sin = qmf_phaseshift_sin_downsamp32;
+        } else {
+          h_Qmf->t_cos = qmf_phaseshift_cos32;
+          h_Qmf->t_sin = qmf_phaseshift_sin32;
+        }
+        h_Qmf->p_stride = 2;
+        h_Qmf->FilterSize = 640;
+        h_Qmf->filterScale = 0;
+        break;
+      case 20:
+        h_Qmf->p_filter = qmf_pfilt200;
+        h_Qmf->p_stride = 1;
+        h_Qmf->FilterSize = 200;
+        h_Qmf->filterScale = 0;
+        break;
+      case 12:
+        h_Qmf->p_filter = qmf_pfilt120;
+        h_Qmf->p_stride = 1;
+        h_Qmf->FilterSize = 120;
+        h_Qmf->filterScale = 0;
+        break;
+      case 8:
+        h_Qmf->p_filter = qmf_pfilt640;
+        h_Qmf->p_stride = 8;
+        h_Qmf->FilterSize = 640;
+        h_Qmf->filterScale = 0;
+        break;
+      case 16:
+        h_Qmf->p_filter = qmf_pfilt640;
+        h_Qmf->t_cos = qmf_phaseshift_cos16;
+        h_Qmf->t_sin = qmf_phaseshift_sin16;
+        h_Qmf->p_stride = 4;
+        h_Qmf->FilterSize = 640;
+        h_Qmf->filterScale = 0;
+        break;
+      case 24:
+        h_Qmf->p_filter = qmf_pfilt240;
+        h_Qmf->t_cos = qmf_phaseshift_cos24;
+        h_Qmf->t_sin = qmf_phaseshift_sin24;
+        h_Qmf->p_stride = 1;
+        h_Qmf->FilterSize = 240;
+        h_Qmf->filterScale = 1;
+        break;
+      default:
+        return -1;
+    }
+  }
+
+  h_Qmf->synScalefactor = h_Qmf->filterScale;
+  // DCT|DST dependency
+  switch (no_channels) {
+    case 128:
+      h_Qmf->synScalefactor += ALGORITHMIC_SCALING_IN_SYNTHESIS_FILTERBANK + 1;
+      break;
+    case 40: {
+      h_Qmf->synScalefactor += ALGORITHMIC_SCALING_IN_SYNTHESIS_FILTERBANK - 1;
+    } break;
+    case 64:
+      h_Qmf->synScalefactor += ALGORITHMIC_SCALING_IN_SYNTHESIS_FILTERBANK;
+      break;
+    case 8:
+      h_Qmf->synScalefactor += ALGORITHMIC_SCALING_IN_SYNTHESIS_FILTERBANK - 3;
+      break;
+    case 12:
+      h_Qmf->synScalefactor += ALGORITHMIC_SCALING_IN_SYNTHESIS_FILTERBANK;
+      break;
+    case 20:
+      h_Qmf->synScalefactor += ALGORITHMIC_SCALING_IN_SYNTHESIS_FILTERBANK + 1;
+      break;
+    case 32:
+      h_Qmf->synScalefactor += ALGORITHMIC_SCALING_IN_SYNTHESIS_FILTERBANK - 1;
+      break;
+    case 16:
+      h_Qmf->synScalefactor += ALGORITHMIC_SCALING_IN_SYNTHESIS_FILTERBANK - 2;
+      break;
+    case 24:
+      h_Qmf->synScalefactor += ALGORITHMIC_SCALING_IN_SYNTHESIS_FILTERBANK - 1;
+      break;
+    default:
+      return -1;
+  }
+
+  h_Qmf->flags = flags;
+
+  h_Qmf->no_channels = no_channels;
+  h_Qmf->no_col = noCols;
+
+  h_Qmf->lsb = fMin(lsb, h_Qmf->no_channels);
+  h_Qmf->usb = synflag
+                   ? fMin(usb, h_Qmf->no_channels)
+                   : usb; /* was: h_Qmf->usb = fMin(usb, h_Qmf->no_channels); */
+
+  h_Qmf->FilterStates = (void *)pFilterStates;
+
+  h_Qmf->outScalefactor =
+      (ALGORITHMIC_SCALING_IN_ANALYSIS_FILTERBANK + h_Qmf->filterScale) +
+      h_Qmf->synScalefactor;
+
+  h_Qmf->outGain_m =
+      (FIXP_DBL)0x80000000; /* default init value will be not applied */
+  h_Qmf->outGain_e = 0;
+
+  return (0);
+}
+
+/*!
+ *
+ * \brief Adjust synthesis qmf filter states
+ *
+ * \return void
+ *
+ */
+static inline void qmfAdaptFilterStates(
+    HANDLE_QMF_FILTER_BANK synQmf, /*!< Handle of Qmf Filter Bank */
+    int scaleFactorDiff)           /*!< Scale factor difference to be applied */
+{
+  if (synQmf == NULL || synQmf->FilterStates == NULL) {
+    return;
+  }
+  if (scaleFactorDiff > 0) {
+    scaleValuesSaturate((FIXP_QSS *)synQmf->FilterStates,
+                        synQmf->no_channels * (QMF_NO_POLY * 2 - 1),
+                        scaleFactorDiff);
+  } else {
+    scaleValues((FIXP_QSS *)synQmf->FilterStates,
+                synQmf->no_channels * (QMF_NO_POLY * 2 - 1), scaleFactorDiff);
+  }
+}
+
+/*!
+ *
+ * \brief Create QMF filter bank instance
+ *
+ *
+ * \return 0 if succesful
+ *
+ */
+int qmfInitAnalysisFilterBank(
+    HANDLE_QMF_FILTER_BANK h_Qmf, /*!< Returns handle */
+    FIXP_QAS *pFilterStates,      /*!< Handle to filter states */
+    int noCols,                   /*!< Number of timeslots per frame */
+    int lsb,                      /*!< lower end of QMF */
+    int usb,                      /*!< upper end of QMF */
+    int no_channels,              /*!< Number of channels (bands) */
+    int flags)                    /*!< Low Power flag */
+{
+  int err = qmfInitFilterBank(h_Qmf, pFilterStates, noCols, lsb, usb,
+                              no_channels, flags, 0);
+  if (!(flags & QMF_FLAG_KEEP_STATES) && (h_Qmf->FilterStates != NULL)) {
+    FDKmemclear(h_Qmf->FilterStates,
+                (2 * QMF_NO_POLY - 1) * h_Qmf->no_channels * sizeof(FIXP_QAS));
+  }
+
+  FDK_ASSERT(h_Qmf->no_channels >= h_Qmf->lsb);
+
+  return err;
+}
+
+/*!
+ *
+ * \brief Create QMF filter bank instance
+ *
+ *
+ * \return 0 if succesful
+ *
+ */
+int qmfInitSynthesisFilterBank(
+    HANDLE_QMF_FILTER_BANK h_Qmf, /*!< Returns handle */
+    FIXP_QSS *pFilterStates,      /*!< Handle to filter states */
+    int noCols,                   /*!< Number of timeslots per frame */
+    int lsb,                      /*!< lower end of QMF */
+    int usb,                      /*!< upper end of QMF */
+    int no_channels,              /*!< Number of channels (bands) */
+    int flags)                    /*!< Low Power flag */
+{
+  int oldOutScale = h_Qmf->outScalefactor;
+  int err = qmfInitFilterBank(h_Qmf, pFilterStates, noCols, lsb, usb,
+                              no_channels, flags, 1);
+  if (h_Qmf->FilterStates != NULL) {
+    if (!(flags & QMF_FLAG_KEEP_STATES)) {
+      FDKmemclear(
+          h_Qmf->FilterStates,
+          (2 * QMF_NO_POLY - 1) * h_Qmf->no_channels * sizeof(FIXP_QSS));
+    } else {
+      qmfAdaptFilterStates(h_Qmf, oldOutScale - h_Qmf->outScalefactor);
+    }
+  }
+
+  FDK_ASSERT(h_Qmf->no_channels >= h_Qmf->lsb);
+  FDK_ASSERT(h_Qmf->no_channels >= h_Qmf->usb);
+
+  return err;
+}
+
+/*!
+ *
+ * \brief Change scale factor for output data and adjust qmf filter states
+ *
+ * \return void
+ *
+ */
+void qmfChangeOutScalefactor(
+    HANDLE_QMF_FILTER_BANK synQmf, /*!< Handle of Qmf Synthesis Bank */
+    int outScalefactor             /*!< New scaling factor for output data */
+) {
+  if (synQmf == NULL) {
+    return;
+  }
+
+  /* Add internal filterbank scale */
+  outScalefactor +=
+      (ALGORITHMIC_SCALING_IN_ANALYSIS_FILTERBANK + synQmf->filterScale) +
+      synQmf->synScalefactor;
+
+  /* adjust filter states when scale factor has been changed */
+  if (synQmf->outScalefactor != outScalefactor) {
+    int diff;
+
+    diff = synQmf->outScalefactor - outScalefactor;
+
+    qmfAdaptFilterStates(synQmf, diff);
+
+    /* save new scale factor */
+    synQmf->outScalefactor = outScalefactor;
+  }
+}
+
+/*!
+ *
+ * \brief Get scale factor change which was set by qmfChangeOutScalefactor()
+ *
+ * \return scaleFactor
+ *
+ */
+int qmfGetOutScalefactor(
+    HANDLE_QMF_FILTER_BANK synQmf) /*!< Handle of Qmf Synthesis Bank */
+{
+  int scaleFactor = synQmf->outScalefactor
+                        ? (synQmf->outScalefactor -
+                           (ALGORITHMIC_SCALING_IN_ANALYSIS_FILTERBANK +
+                            synQmf->filterScale + synQmf->synScalefactor))
+                        : 0;
+  return scaleFactor;
+}
+
+/*!
+ *
+ * \brief Change gain for output data
+ *
+ * \return void
+ *
+ */
+void qmfChangeOutGain(
+    HANDLE_QMF_FILTER_BANK synQmf, /*!< Handle of Qmf Synthesis Bank */
+    FIXP_DBL outputGain,           /*!< New gain for output data (mantissa) */
+    int outputGainScale            /*!< New gain for output data (exponent) */
+) {
+  synQmf->outGain_m = outputGain;
+  synQmf->outGain_e = outputGainScale;
+}
+
+/* When QMF_16IN_32OUT is set, synthesis functions for 16 and 32 bit parallel
+ * output is compiled */
+#define INT_PCM_QMFOUT INT_PCM
+#define SAMPLE_BITS_QMFOUT SAMPLE_BITS
+#include "qmf_pcm.h"