Merge GStreamer into next

1 files changed, 582 insertions, 0 deletions

diff --git a/fdk-aac/libAACenc/src/block_switch.cpp b/fdk-aac/libAACenc/src/block_switch.cpp
new file mode 100644
index 0000000..c132253
--- /dev/null
+++ b/fdk-aac/libAACenc/src/block_switch.cpp
@@ -0,0 +1,582 @@
+/* -----------------------------------------------------------------------------
+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
+----------------------------------------------------------------------------- */
+
+/**************************** AAC encoder library ******************************
+
+   Author(s):   M. Werner, Tobias Chalupka
+
+   Description: Block switching
+
+*******************************************************************************/
+
+/****************** Includes *****************************/
+
+#include "block_switch.h"
+#include "genericStds.h"
+
+#define LOWOV_WINDOW _LOWOV_WINDOW
+
+/**************** internal function prototypes ***********/
+
+static FIXP_DBL FDKaacEnc_GetWindowEnergy(const FIXP_DBL in[],
+                                          const INT blSwWndIdx);
+
+static void FDKaacEnc_CalcWindowEnergy(
+    BLOCK_SWITCHING_CONTROL *RESTRICT blockSwitchingControl, INT windowLen,
+    const INT_PCM *pTimeSignal);
+
+/****************** Constants *****************************/
+/*                                                LONG         START
+ * SHORT         STOP         LOWOV                  */
+static const INT blockType2windowShape[2][5] = {
+    {SINE_WINDOW, KBD_WINDOW, WRONG_WINDOW, SINE_WINDOW, KBD_WINDOW},  /* LD */
+    {KBD_WINDOW, SINE_WINDOW, SINE_WINDOW, KBD_WINDOW, WRONG_WINDOW}}; /* LC */
+
+/* IIR high pass coeffs */
+
+#ifndef SINETABLE_16BIT
+
+static const FIXP_DBL hiPassCoeff[BLOCK_SWITCHING_IIR_LEN] = {
+    FL2FXCONST_DBL(-0.5095), FL2FXCONST_DBL(0.7548)};
+
+static const FIXP_DBL accWindowNrgFac =
+    FL2FXCONST_DBL(0.3f); /* factor for accumulating filtered window energies */
+static const FIXP_DBL oneMinusAccWindowNrgFac = FL2FXCONST_DBL(0.7f);
+/* static const float attackRatio = 10.0; */ /* lower ratio limit for attacks */
+static const FIXP_DBL invAttackRatio =
+    FL2FXCONST_DBL(0.1f); /* inverted lower ratio limit for attacks */
+
+/* The next constants are scaled, because they are used for comparison with
+ * scaled values*/
+/* minimum energy for attacks */
+static const FIXP_DBL minAttackNrg =
+    (FL2FXCONST_DBL(1e+6f * NORM_PCM_ENERGY) >>
+     BLOCK_SWITCH_ENERGY_SHIFT); /* minimum energy for attacks */
+
+#else
+
+static const FIXP_SGL hiPassCoeff[BLOCK_SWITCHING_IIR_LEN] = {
+    FL2FXCONST_SGL(-0.5095), FL2FXCONST_SGL(0.7548)};
+
+static const FIXP_DBL accWindowNrgFac =
+    FL2FXCONST_DBL(0.3f); /* factor for accumulating filtered window energies */
+static const FIXP_SGL oneMinusAccWindowNrgFac = FL2FXCONST_SGL(0.7f);
+/* static const float attackRatio = 10.0; */ /* lower ratio limit for attacks */
+static const FIXP_SGL invAttackRatio =
+    FL2FXCONST_SGL(0.1f); /* inverted lower ratio limit for attacks */
+/* minimum energy for attacks */
+static const FIXP_DBL minAttackNrg =
+    (FL2FXCONST_DBL(1e+6f * NORM_PCM_ENERGY) >>
+     BLOCK_SWITCH_ENERGY_SHIFT); /* minimum energy for attacks */
+
+#endif
+
+/**************** internal function prototypes ***********/
+
+/****************** Routines ****************************/
+void FDKaacEnc_InitBlockSwitching(
+    BLOCK_SWITCHING_CONTROL *blockSwitchingControl, INT isLowDelay) {
+  FDKmemclear(blockSwitchingControl, sizeof(BLOCK_SWITCHING_CONTROL));
+
+  if (isLowDelay) {
+    blockSwitchingControl->nBlockSwitchWindows = 4;
+    blockSwitchingControl->allowShortFrames = 0;
+    blockSwitchingControl->allowLookAhead = 0;
+  } else {
+    blockSwitchingControl->nBlockSwitchWindows = 8;
+    blockSwitchingControl->allowShortFrames = 1;
+    blockSwitchingControl->allowLookAhead = 1;
+  }
+
+  blockSwitchingControl->noOfGroups = MAX_NO_OF_GROUPS;
+
+  /* Initialize startvalue for blocktype */
+  blockSwitchingControl->lastWindowSequence = LONG_WINDOW;
+  blockSwitchingControl->windowShape =
+      blockType2windowShape[blockSwitchingControl->allowShortFrames]
+                           [blockSwitchingControl->lastWindowSequence];
+}
+
+static const INT suggestedGroupingTable[TRANS_FAC][MAX_NO_OF_GROUPS] = {
+    /* Attack in Window 0 */ {1, 3, 3, 1},
+    /* Attack in Window 1 */ {1, 1, 3, 3},
+    /* Attack in Window 2 */ {2, 1, 3, 2},
+    /* Attack in Window 3 */ {3, 1, 3, 1},
+    /* Attack in Window 4 */ {3, 1, 1, 3},
+    /* Attack in Window 5 */ {3, 2, 1, 2},
+    /* Attack in Window 6 */ {3, 3, 1, 1},
+    /* Attack in Window 7 */ {3, 3, 1, 1}};
+
+/* change block type depending on current blocktype and whether there's an
+ * attack */
+/* assume no look-ahead */
+static const INT chgWndSq[2][N_BLOCKTYPES] = {
+    /*             LONG WINDOW   START_WINDOW  SHORT_WINDOW  STOP_WINDOW,
+       LOWOV_WINDOW, WRONG_WINDOW */
+    /*no attack*/ {LONG_WINDOW, STOP_WINDOW, WRONG_WINDOW, LONG_WINDOW,
+                   STOP_WINDOW, WRONG_WINDOW},
+    /*attack   */ {START_WINDOW, LOWOV_WINDOW, WRONG_WINDOW, START_WINDOW,
+                   LOWOV_WINDOW, WRONG_WINDOW}};
+
+/* change block type depending on current blocktype and whether there's an
+ * attack */
+/* assume look-ahead */
+static const INT chgWndSqLkAhd[2][2][N_BLOCKTYPES] = {
+    /*attack         LONG WINDOW    START_WINDOW   SHORT_WINDOW   STOP_WINDOW   LOWOV_WINDOW, WRONG_WINDOW */ /* last attack */
+    /*no attack*/ {
+        {LONG_WINDOW, SHORT_WINDOW, STOP_WINDOW, LONG_WINDOW, WRONG_WINDOW,
+         WRONG_WINDOW}, /* no attack   */
+        /*attack   */ {START_WINDOW, SHORT_WINDOW, SHORT_WINDOW, START_WINDOW,
+                       WRONG_WINDOW, WRONG_WINDOW}}, /* no attack   */
+    /*no attack*/ {{LONG_WINDOW, SHORT_WINDOW, SHORT_WINDOW, LONG_WINDOW,
+                    WRONG_WINDOW, WRONG_WINDOW}, /* attack      */
+                   /*attack   */ {START_WINDOW, SHORT_WINDOW, SHORT_WINDOW,
+                                  START_WINDOW, WRONG_WINDOW,
+                                  WRONG_WINDOW}} /* attack      */
+};
+
+int FDKaacEnc_BlockSwitching(BLOCK_SWITCHING_CONTROL *blockSwitchingControl,
+                             const INT granuleLength, const int isLFE,
+                             const INT_PCM *pTimeSignal) {
+  UINT i;
+  FIXP_DBL enM1, enMax;
+
+  UINT nBlockSwitchWindows = blockSwitchingControl->nBlockSwitchWindows;
+
+  /* for LFE : only LONG window allowed */
+  if (isLFE) {
+    /* case LFE: */
+    /* only long blocks, always use sine windows (MPEG2 AAC, MPEG4 AAC) */
+    blockSwitchingControl->lastWindowSequence = LONG_WINDOW;
+    blockSwitchingControl->windowShape = SINE_WINDOW;
+    blockSwitchingControl->noOfGroups = 1;
+    blockSwitchingControl->groupLen[0] = 1;
+
+    return (0);
+  };
+
+  /* Save current attack index as last attack index */
+  blockSwitchingControl->lastattack = blockSwitchingControl->attack;
+  blockSwitchingControl->lastAttackIndex = blockSwitchingControl->attackIndex;
+
+  /* Save current window energy as last window energy */
+  FDKmemcpy(blockSwitchingControl->windowNrg[0],
+            blockSwitchingControl->windowNrg[1],
+            sizeof(blockSwitchingControl->windowNrg[0]));
+  FDKmemcpy(blockSwitchingControl->windowNrgF[0],
+            blockSwitchingControl->windowNrgF[1],
+            sizeof(blockSwitchingControl->windowNrgF[0]));
+
+  if (blockSwitchingControl->allowShortFrames) {
+    /* Calculate suggested grouping info for the last frame */
+
+    /* Reset grouping info */
+    FDKmemclear(blockSwitchingControl->groupLen,
+                sizeof(blockSwitchingControl->groupLen));
+
+    /* Set grouping info */
+    blockSwitchingControl->noOfGroups = MAX_NO_OF_GROUPS;
+
+    FDKmemcpy(blockSwitchingControl->groupLen,
+              suggestedGroupingTable[blockSwitchingControl->lastAttackIndex],
+              sizeof(blockSwitchingControl->groupLen));
+
+    if (blockSwitchingControl->attack == TRUE)
+      blockSwitchingControl->maxWindowNrg =
+          FDKaacEnc_GetWindowEnergy(blockSwitchingControl->windowNrg[0],
+                                    blockSwitchingControl->lastAttackIndex);
+    else
+      blockSwitchingControl->maxWindowNrg = FL2FXCONST_DBL(0.0);
+  }
+
+  /* Calculate unfiltered and filtered energies in subwindows and combine to
+   * segments */
+  FDKaacEnc_CalcWindowEnergy(
+      blockSwitchingControl,
+      granuleLength >> (nBlockSwitchWindows == 4 ? 2 : 3), pTimeSignal);
+
+  /* now calculate if there is an attack */
+
+  /* reset attack */
+  blockSwitchingControl->attack = FALSE;
+
+  /* look for attack */
+  enMax = FL2FXCONST_DBL(0.0f);
+  enM1 = blockSwitchingControl->windowNrgF[0][nBlockSwitchWindows - 1];
+
+  for (i = 0; i < nBlockSwitchWindows; i++) {
+    FIXP_DBL tmp =
+        fMultDiv2(oneMinusAccWindowNrgFac, blockSwitchingControl->accWindowNrg);
+    blockSwitchingControl->accWindowNrg = fMultAdd(tmp, accWindowNrgFac, enM1);
+
+    if (fMult(blockSwitchingControl->windowNrgF[1][i], invAttackRatio) >
+        blockSwitchingControl->accWindowNrg) {
+      blockSwitchingControl->attack = TRUE;
+      blockSwitchingControl->attackIndex = i;
+    }
+    enM1 = blockSwitchingControl->windowNrgF[1][i];
+    enMax = fixMax(enMax, enM1);
+  }
+
+  if (enMax < minAttackNrg) blockSwitchingControl->attack = FALSE;
+
+  /* Check if attack spreads over frame border */
+  if ((blockSwitchingControl->attack == FALSE) &&
+      (blockSwitchingControl->lastattack == TRUE)) {
+    /* if attack is in last window repeat SHORT_WINDOW */
+    if (((blockSwitchingControl->windowNrgF[0][nBlockSwitchWindows - 1] >> 4) >
+         fMult((FIXP_DBL)(10 << (DFRACT_BITS - 1 - 4)),
+               blockSwitchingControl->windowNrgF[1][1])) &&
+        (blockSwitchingControl->lastAttackIndex ==
+         (INT)nBlockSwitchWindows - 1)) {
+      blockSwitchingControl->attack = TRUE;
+      blockSwitchingControl->attackIndex = 0;
+    }
+  }
+
+  if (blockSwitchingControl->allowLookAhead) {
+    blockSwitchingControl->lastWindowSequence =
+        chgWndSqLkAhd[blockSwitchingControl->lastattack]
+                     [blockSwitchingControl->attack]
+                     [blockSwitchingControl->lastWindowSequence];
+  } else {
+    /* Low Delay */
+    blockSwitchingControl->lastWindowSequence =
+        chgWndSq[blockSwitchingControl->attack]
+                [blockSwitchingControl->lastWindowSequence];
+  }
+
+  /* update window shape */
+  blockSwitchingControl->windowShape =
+      blockType2windowShape[blockSwitchingControl->allowShortFrames]
+                           [blockSwitchingControl->lastWindowSequence];
+
+  return (0);
+}
+
+static FIXP_DBL FDKaacEnc_GetWindowEnergy(const FIXP_DBL in[],
+                                          const INT blSwWndIdx) {
+  /* For coherency, change FDKaacEnc_GetWindowEnergy() to calcluate the energy
+     for a block switching analysis windows, not for a short block. The same is
+     done FDKaacEnc_CalcWindowEnergy(). The result of
+     FDKaacEnc_GetWindowEnergy() is used for a comparision of the max energy of
+     left/right channel. */
+
+  return in[blSwWndIdx];
+}
+
+static void FDKaacEnc_CalcWindowEnergy(
+    BLOCK_SWITCHING_CONTROL *RESTRICT blockSwitchingControl, INT windowLen,
+    const INT_PCM *pTimeSignal) {
+  INT i;
+  UINT w;
+
+#ifndef SINETABLE_16BIT
+  const FIXP_DBL hiPassCoeff0 = hiPassCoeff[0];
+  const FIXP_DBL hiPassCoeff1 = hiPassCoeff[1];
+#else
+  const FIXP_SGL hiPassCoeff0 = hiPassCoeff[0];
+  const FIXP_SGL hiPassCoeff1 = hiPassCoeff[1];
+#endif
+
+  FIXP_DBL temp_iirState0 = blockSwitchingControl->iirStates[0];
+  FIXP_DBL temp_iirState1 = blockSwitchingControl->iirStates[1];
+
+  /* sum up scalarproduct of timesignal as windowed Energies */
+  for (w = 0; w < blockSwitchingControl->nBlockSwitchWindows; w++) {
+    ULONG temp_windowNrg = 0x0;
+    ULONG temp_windowNrgF = 0x0;
+
+    /* windowNrg = sum(timesample^2) */
+    for (i = 0; i < windowLen; i++) {
+      FIXP_DBL tempUnfiltered, t1, t2;
+      /* tempUnfiltered is scaled with 1 to prevent overflows during calculation
+       * of tempFiltred */
+#if SAMPLE_BITS == DFRACT_BITS
+      tempUnfiltered = (FIXP_DBL)*pTimeSignal++ >> 1;
+#else
+      tempUnfiltered = (FIXP_DBL)*pTimeSignal++
+                       << (DFRACT_BITS - SAMPLE_BITS - 1);
+#endif
+      t1 = fMultDiv2(hiPassCoeff1, tempUnfiltered - temp_iirState0);
+      t2 = fMultDiv2(hiPassCoeff0, temp_iirState1);
+      temp_iirState0 = tempUnfiltered;
+      temp_iirState1 = (t1 - t2) << 1;
+
+      temp_windowNrg += (LONG)fPow2Div2(temp_iirState0) >>
+                        (BLOCK_SWITCH_ENERGY_SHIFT - 1 - 2);
+      temp_windowNrgF += (LONG)fPow2Div2(temp_iirState1) >>
+                         (BLOCK_SWITCH_ENERGY_SHIFT - 1 - 2);
+    }
+    blockSwitchingControl->windowNrg[1][w] =
+        (LONG)fMin(temp_windowNrg, (UINT)MAXVAL_DBL);
+    blockSwitchingControl->windowNrgF[1][w] =
+        (LONG)fMin(temp_windowNrgF, (UINT)MAXVAL_DBL);
+  }
+  blockSwitchingControl->iirStates[0] = temp_iirState0;
+  blockSwitchingControl->iirStates[1] = temp_iirState1;
+}
+
+static const UCHAR synchronizedBlockTypeTable[5][5] = {
+    /*                  LONG_WINDOW   START_WINDOW  SHORT_WINDOW  STOP_WINDOW
+       LOWOV_WINDOW*/
+    /* LONG_WINDOW  */ {LONG_WINDOW, START_WINDOW, SHORT_WINDOW, STOP_WINDOW,
+                        LOWOV_WINDOW},
+    /* START_WINDOW */
+    {START_WINDOW, START_WINDOW, SHORT_WINDOW, SHORT_WINDOW, LOWOV_WINDOW},
+    /* SHORT_WINDOW */
+    {SHORT_WINDOW, SHORT_WINDOW, SHORT_WINDOW, SHORT_WINDOW, WRONG_WINDOW},
+    /* STOP_WINDOW  */
+    {STOP_WINDOW, SHORT_WINDOW, SHORT_WINDOW, STOP_WINDOW, LOWOV_WINDOW},
+    /* LOWOV_WINDOW */
+    {LOWOV_WINDOW, LOWOV_WINDOW, WRONG_WINDOW, LOWOV_WINDOW, LOWOV_WINDOW},
+};
+
+int FDKaacEnc_SyncBlockSwitching(
+    BLOCK_SWITCHING_CONTROL *blockSwitchingControlLeft,
+    BLOCK_SWITCHING_CONTROL *blockSwitchingControlRight, const INT nChannels,
+    const INT commonWindow) {
+  UCHAR patchType = LONG_WINDOW;
+
+  if (nChannels == 2 && commonWindow == TRUE) {
+    /* could be better with a channel loop (need a handle to psy_data) */
+    /* get suggested Block Types and synchronize */
+    patchType = synchronizedBlockTypeTable[patchType][blockSwitchingControlLeft
+                                                          ->lastWindowSequence];
+    patchType = synchronizedBlockTypeTable[patchType][blockSwitchingControlRight
+                                                          ->lastWindowSequence];
+
+    /* sanity check (no change from low overlap window to short winow and vice
+     * versa) */
+    if (patchType == WRONG_WINDOW) return -1; /* mixed up AAC-LC and AAC-LD */
+
+    /* Set synchronized Blocktype */
+    blockSwitchingControlLeft->lastWindowSequence = patchType;
+    blockSwitchingControlRight->lastWindowSequence = patchType;
+
+    /* update window shape */
+    blockSwitchingControlLeft->windowShape =
+        blockType2windowShape[blockSwitchingControlLeft->allowShortFrames]
+                             [blockSwitchingControlLeft->lastWindowSequence];
+    blockSwitchingControlRight->windowShape =
+        blockType2windowShape[blockSwitchingControlLeft->allowShortFrames]
+                             [blockSwitchingControlRight->lastWindowSequence];
+  }
+
+  if (blockSwitchingControlLeft->allowShortFrames) {
+    int i;
+
+    if (nChannels == 2) {
+      if (commonWindow == TRUE) {
+        /* Synchronize grouping info */
+        int windowSequenceLeftOld =
+            blockSwitchingControlLeft->lastWindowSequence;
+        int windowSequenceRightOld =
+            blockSwitchingControlRight->lastWindowSequence;
+
+        /* Long Blocks */
+        if (patchType != SHORT_WINDOW) {
+          /* Set grouping info */
+          blockSwitchingControlLeft->noOfGroups = 1;
+          blockSwitchingControlRight->noOfGroups = 1;
+          blockSwitchingControlLeft->groupLen[0] = 1;
+          blockSwitchingControlRight->groupLen[0] = 1;
+
+          for (i = 1; i < MAX_NO_OF_GROUPS; i++) {
+            blockSwitchingControlLeft->groupLen[i] = 0;
+            blockSwitchingControlRight->groupLen[i] = 0;
+          }
+        }
+
+        /* Short Blocks */
+        else {
+          /* in case all two channels were detected as short-blocks before
+           * syncing, use the grouping of channel with higher maxWindowNrg */
+          if ((windowSequenceLeftOld == SHORT_WINDOW) &&
+              (windowSequenceRightOld == SHORT_WINDOW)) {
+            if (blockSwitchingControlLeft->maxWindowNrg >
+                blockSwitchingControlRight->maxWindowNrg) {
+              /* Left Channel wins */
+              blockSwitchingControlRight->noOfGroups =
+                  blockSwitchingControlLeft->noOfGroups;
+              for (i = 0; i < MAX_NO_OF_GROUPS; i++) {
+                blockSwitchingControlRight->groupLen[i] =
+                    blockSwitchingControlLeft->groupLen[i];
+              }
+            } else {
+              /* Right Channel wins */
+              blockSwitchingControlLeft->noOfGroups =
+                  blockSwitchingControlRight->noOfGroups;
+              for (i = 0; i < MAX_NO_OF_GROUPS; i++) {
+                blockSwitchingControlLeft->groupLen[i] =
+                    blockSwitchingControlRight->groupLen[i];
+              }
+            }
+          } else if ((windowSequenceLeftOld == SHORT_WINDOW) &&
+                     (windowSequenceRightOld != SHORT_WINDOW)) {
+            /* else use grouping of short-block channel */
+            blockSwitchingControlRight->noOfGroups =
+                blockSwitchingControlLeft->noOfGroups;
+            for (i = 0; i < MAX_NO_OF_GROUPS; i++) {
+              blockSwitchingControlRight->groupLen[i] =
+                  blockSwitchingControlLeft->groupLen[i];
+            }
+          } else if ((windowSequenceRightOld == SHORT_WINDOW) &&
+                     (windowSequenceLeftOld != SHORT_WINDOW)) {
+            blockSwitchingControlLeft->noOfGroups =
+                blockSwitchingControlRight->noOfGroups;
+            for (i = 0; i < MAX_NO_OF_GROUPS; i++) {
+              blockSwitchingControlLeft->groupLen[i] =
+                  blockSwitchingControlRight->groupLen[i];
+            }
+          } else {
+            /* syncing a start and stop window ... */
+            blockSwitchingControlLeft->noOfGroups =
+                blockSwitchingControlRight->noOfGroups = 2;
+            blockSwitchingControlLeft->groupLen[0] =
+                blockSwitchingControlRight->groupLen[0] = 4;
+            blockSwitchingControlLeft->groupLen[1] =
+                blockSwitchingControlRight->groupLen[1] = 4;
+          }
+        } /* Short Blocks */
+      } else {
+        /* stereo, no common window */
+        if (blockSwitchingControlLeft->lastWindowSequence != SHORT_WINDOW) {
+          blockSwitchingControlLeft->noOfGroups = 1;
+          blockSwitchingControlLeft->groupLen[0] = 1;
+          for (i = 1; i < MAX_NO_OF_GROUPS; i++) {
+            blockSwitchingControlLeft->groupLen[i] = 0;
+          }
+        }
+        if (blockSwitchingControlRight->lastWindowSequence != SHORT_WINDOW) {
+          blockSwitchingControlRight->noOfGroups = 1;
+          blockSwitchingControlRight->groupLen[0] = 1;
+          for (i = 1; i < MAX_NO_OF_GROUPS; i++) {
+            blockSwitchingControlRight->groupLen[i] = 0;
+          }
+        }
+      } /* common window */
+    } else {
+      /* Mono */
+      if (blockSwitchingControlLeft->lastWindowSequence != SHORT_WINDOW) {
+        blockSwitchingControlLeft->noOfGroups = 1;
+        blockSwitchingControlLeft->groupLen[0] = 1;
+
+        for (i = 1; i < MAX_NO_OF_GROUPS; i++) {
+          blockSwitchingControlLeft->groupLen[i] = 0;
+        }
+      }
+    }
+  } /* allowShortFrames */
+
+  /* Translate LOWOV_WINDOW block type to a meaningful window shape. */
+  if (!blockSwitchingControlLeft->allowShortFrames) {
+    if (blockSwitchingControlLeft->lastWindowSequence != LONG_WINDOW &&
+        blockSwitchingControlLeft->lastWindowSequence != STOP_WINDOW) {
+      blockSwitchingControlLeft->lastWindowSequence = LONG_WINDOW;
+      blockSwitchingControlLeft->windowShape = LOL_WINDOW;
+    }
+  }
+  if (nChannels == 2) {
+    if (!blockSwitchingControlRight->allowShortFrames) {
+      if (blockSwitchingControlRight->lastWindowSequence != LONG_WINDOW &&
+          blockSwitchingControlRight->lastWindowSequence != STOP_WINDOW) {
+        blockSwitchingControlRight->lastWindowSequence = LONG_WINDOW;
+        blockSwitchingControlRight->windowShape = LOL_WINDOW;
+      }
+    }
+  }
+
+  return 0;
+}