/src/aac/libSBRenc/src/fram_gen.cpp

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

/**************************** SBR encoder library ******************************

   Author(s):

   Description:

*******************************************************************************/

#include "fram_gen.h"
#include "sbr_misc.h"

#include "genericStds.h"

static const SBR_FRAME_INFO frameInfo1_2048 = {1, {0, 16}, {FREQ_RES_HIGH},
                                               0, 1,       {0, 16}};

static const SBR_FRAME_INFO frameInfo2_2048 = {
    2, {0, 8, 16}, {FREQ_RES_HIGH, FREQ_RES_HIGH}, 0, 2, {0, 8, 16}};

static const SBR_FRAME_INFO frameInfo4_2048 = {
    4,
    {0, 4, 8, 12, 16},
    {FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH},
    0,
    2,
    {0, 8, 16}};

static const SBR_FRAME_INFO frameInfo1_2304 = {1, {0, 18}, {FREQ_RES_HIGH},
                                               0, 1,       {0, 18}};

static const SBR_FRAME_INFO frameInfo2_2304 = {
    2, {0, 9, 18}, {FREQ_RES_HIGH, FREQ_RES_HIGH}, 0, 2, {0, 9, 18}};

static const SBR_FRAME_INFO frameInfo4_2304 = {
    4,
    {0, 5, 9, 14, 18},
    {FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH},
    0,
    2,
    {0, 9, 18}};

static const SBR_FRAME_INFO frameInfo1_1920 = {1, {0, 15}, {FREQ_RES_HIGH},
                                               0, 1,       {0, 15}};

static const SBR_FRAME_INFO frameInfo2_1920 = {
    2, {0, 8, 15}, {FREQ_RES_HIGH, FREQ_RES_HIGH}, 0, 2, {0, 8, 15}};

static const SBR_FRAME_INFO frameInfo4_1920 = {
    4,
    {0, 4, 8, 12, 15},
    {FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH},
    0,
    2,
    {0, 8, 15}};

static const SBR_FRAME_INFO frameInfo1_1152 = {1, {0, 9}, {FREQ_RES_HIGH},
                                               0, 1,      {0, 9}};

static const SBR_FRAME_INFO frameInfo2_1152 = {
    2, {0, 5, 9}, {FREQ_RES_HIGH, FREQ_RES_HIGH}, 0, 2, {0, 5, 9}};

static const SBR_FRAME_INFO frameInfo4_1152 = {
    4,
    {0, 2, 5, 7, 9},
    {FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH},
    0,
    2,
    {0, 5, 9}};

/* AACLD frame info */
static const SBR_FRAME_INFO frameInfo1_512LD = {1, {0, 8}, {FREQ_RES_HIGH},
                                                0, 1,      {0, 8}};

static const SBR_FRAME_INFO frameInfo2_512LD = {
    2, {0, 4, 8}, {FREQ_RES_HIGH, FREQ_RES_HIGH}, 0, 2, {0, 4, 8}};

static const SBR_FRAME_INFO frameInfo4_512LD = {
    4,
    {0, 2, 4, 6, 8},
    {FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH},
    0,
    2,
    {0, 4, 8}};

static int calcFillLengthMax(
    int tranPos,        /*!< input : transient position (ref: tran det) */
    int numberTimeSlots /*!< input : number of timeslots */
);

static void fillFrameTran(
    const int *v_tuningSegm, /*!< tuning: desired segment lengths */
    const int *v_tuningFreq, /*!< tuning: desired frequency resolutions */
    int tran,                /*!< input : position of transient */
    int *v_bord,             /*!< memNew: borders */
    int *length_v_bord,      /*!< memNew: # borders */
    int *v_freq,             /*!< memNew: frequency resolutions */
    int *length_v_freq,      /*!< memNew: # frequency resolutions */
    int *bmin,               /*!< hlpNew: first mandatory border */
    int *bmax                /*!< hlpNew: last  mandatory border */
);

static void fillFramePre(INT dmax, INT *v_bord, INT *length_v_bord, INT *v_freq,
                         INT *length_v_freq, INT bmin, INT rest);

static void fillFramePost(INT *parts, INT *d, INT dmax, INT *v_bord,
                          INT *length_v_bord, INT *v_freq, INT *length_v_freq,
                          INT bmax, INT bufferFrameStart, INT numberTimeSlots,
                          INT fmax);

static void fillFrameInter(INT *nL, const int *v_tuningSegm, INT *v_bord,
                           INT *length_v_bord, INT bmin, INT *v_freq,
                           INT *length_v_freq, INT *v_bordFollow,
                           INT *length_v_bordFollow, INT *v_freqFollow,
                           INT *length_v_freqFollow, INT i_fillFollow, INT dmin,
                           INT dmax, INT numberTimeSlots);

static void calcFrameClass(FRAME_CLASS *frameClass, FRAME_CLASS *frameClassOld,
                           INT tranFlag, INT *spreadFlag);

static void specialCase(INT *spreadFlag, INT allowSpread, INT *v_bord,
                        INT *length_v_bord, INT *v_freq, INT *length_v_freq,
                        INT *parts, INT d);

static void calcCmonBorder(INT *i_cmon, INT *i_tran, INT *v_bord,
                           INT *length_v_bord, INT tran, INT bufferFrameStart,
                           INT numberTimeSlots);

static void keepForFollowUp(INT *v_bordFollow, INT *length_v_bordFollow,
                            INT *v_freqFollow, INT *length_v_freqFollow,
                            INT *i_tranFollow, INT *i_fillFollow, INT *v_bord,
                            INT *length_v_bord, INT *v_freq, INT i_cmon,
                            INT i_tran, INT parts, INT numberTimeSlots);

static void calcCtrlSignal(HANDLE_SBR_GRID hSbrGrid, FRAME_CLASS frameClass,
                           INT *v_bord, INT length_v_bord, INT *v_freq,
                           INT length_v_freq, INT i_cmon, INT i_tran,
                           INT spreadFlag, INT nL);

static void ctrlSignal2FrameInfo(HANDLE_SBR_GRID hSbrGrid,
                                 HANDLE_SBR_FRAME_INFO hFrameInfo,
                                 FREQ_RES *freq_res_fixfix);

/* table for 8 time slot index */
static const int envelopeTable_8[8][5] = {
    /* transientIndex  nEnv, tranIdx, shortEnv, border1, border2, ... */
    /* borders from left to right side; -1 = not in use */
    /*[|T-|------]*/ {2, 0, 0, 1, -1},
    /*[|-T-|-----]*/ {2, 0, 0, 2, -1},
    /*[--|T-|----]*/ {3, 1, 1, 2, 4},
    /*[---|T-|---]*/ {3, 1, 1, 3, 5},
    /*[----|T-|--]*/ {3, 1, 1, 4, 6},
    /*[-----|T--|]*/ {2, 1, 1, 5, -1},
    /*[------|T-|]*/ {2, 1, 1, 6, -1},
    /*[-------|T|]*/ {2, 1, 1, 7, -1},
};

/* table for 16 time slot index */
static const int envelopeTable_16[16][6] = {
    /* transientIndex  nEnv, tranIdx, shortEnv, border1, border2, ... */
    /* length from left to right side; -1 = not in use */
    /*[|T---|------------|]*/ {2, 0, 0, 4, -1, -1},
    /*[|-T---|-----------|]*/ {2, 0, 0, 5, -1, -1},
    /*[|--|T---|----------]*/ {3, 1, 1, 2, 6, -1},
    /*[|---|T---|---------]*/ {3, 1, 1, 3, 7, -1},
    /*[|----|T---|--------]*/ {3, 1, 1, 4, 8, -1},
    /*[|-----|T---|-------]*/ {3, 1, 1, 5, 9, -1},
    /*[|------|T---|------]*/ {3, 1, 1, 6, 10, -1},
    /*[|-------|T---|-----]*/ {3, 1, 1, 7, 11, -1},
    /*[|--------|T---|----]*/ {3, 1, 1, 8, 12, -1},
    /*[|---------|T---|---]*/ {3, 1, 1, 9, 13, -1},
    /*[|----------|T---|--]*/ {3, 1, 1, 10, 14, -1},
    /*[|-----------|T----|]*/ {2, 1, 1, 11, -1, -1},
    /*[|------------|T---|]*/ {2, 1, 1, 12, -1, -1},
    /*[|-------------|T--|]*/ {2, 1, 1, 13, -1, -1},
    /*[|--------------|T-|]*/ {2, 1, 1, 14, -1, -1},
    /*[|---------------|T|]*/ {2, 1, 1, 15, -1, -1},
};

/* table for 15 time slot index */
static const int envelopeTable_15[15][6] = {
    /* transientIndex  nEnv, tranIdx, shortEnv, border1, border2, ... */
    /* length from left to right side; -1 = not in use */
    /*[|T---|------------]*/ {2, 0, 0, 4, -1, -1},
    /*[|-T---|-----------]*/ {2, 0, 0, 5, -1, -1},
    /*[|--|T---|---------]*/ {3, 1, 1, 2, 6, -1},
    /*[|---|T---|--------]*/ {3, 1, 1, 3, 7, -1},
    /*[|----|T---|-------]*/ {3, 1, 1, 4, 8, -1},
    /*[|-----|T---|------]*/ {3, 1, 1, 5, 9, -1},
    /*[|------|T---|-----]*/ {3, 1, 1, 6, 10, -1},
    /*[|-------|T---|----]*/ {3, 1, 1, 7, 11, -1},
    /*[|--------|T---|---]*/ {3, 1, 1, 8, 12, -1},
    /*[|---------|T---|--]*/ {3, 1, 1, 9, 13, -1},
    /*[|----------|T----|]*/ {2, 1, 1, 10, -1, -1},
    /*[|-----------|T---|]*/ {2, 1, 1, 11, -1, -1},
    /*[|------------|T--|]*/ {2, 1, 1, 12, -1, -1},
    /*[|-------------|T-|]*/ {2, 1, 1, 13, -1, -1},
    /*[|--------------|T|]*/ {2, 1, 1, 14, -1, -1},
};

static const int minFrameTranDistance = 4;

static const FREQ_RES freqRes_table_8[] = {
    FREQ_RES_LOW,  FREQ_RES_LOW,  FREQ_RES_LOW,  FREQ_RES_LOW, FREQ_RES_LOW,
    FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH, FREQ_RES_HIGH};

static const FREQ_RES freqRes_table_16[16] = {
    /* size of envelope */
    /* 0-4 */ FREQ_RES_LOW,
    FREQ_RES_LOW,
    FREQ_RES_LOW,
    FREQ_RES_LOW,
    FREQ_RES_LOW,
    /* 5-9 */ FREQ_RES_LOW,
    FREQ_RES_HIGH,
    FREQ_RES_HIGH,
    FREQ_RES_HIGH,
    FREQ_RES_HIGH,
    /* 10-16 */ FREQ_RES_HIGH,
    FREQ_RES_HIGH,
    FREQ_RES_HIGH,
    FREQ_RES_HIGH,
    FREQ_RES_HIGH,
    FREQ_RES_HIGH};

static void generateFixFixOnly(HANDLE_SBR_FRAME_INFO hSbrFrameInfo,
                               HANDLE_SBR_GRID hSbrGrid, int tranPosInternal,
                               int numberTimeSlots, UCHAR fResTransIsLow);

/*!
  Functionname: FDKsbrEnc_frameInfoGenerator

  Description:  produces the FRAME_INFO struct for the current frame

  Arguments:    hSbrEnvFrame          - pointer to sbr envelope handle
                v_pre_transient_info  - pointer to transient info vector
                v_transient_info      - pointer to previous transient info
vector v_tuning              - pointer to tuning vector

 Return:      frame_info        - pointer to SBR_FRAME_INFO struct

*******************************************************************************/
HANDLE_SBR_FRAME_INFO
FDKsbrEnc_frameInfoGenerator(HANDLE_SBR_ENVELOPE_FRAME hSbrEnvFrame,
                             UCHAR *v_transient_info, const INT rightBorderFIX,
                             UCHAR *v_transient_info_pre, int ldGrid,
                             const int *v_tuning) {
  INT numEnv, tranPosInternal = 0, bmin = 0, bmax = 0, parts, d, i_cmon = 0,
              i_tran = 0, nL;
  INT fmax = 0;

  INT *v_bord = hSbrEnvFrame->v_bord;
  INT *v_freq = hSbrEnvFrame->v_freq;
  INT *v_bordFollow = hSbrEnvFrame->v_bordFollow;
  INT *v_freqFollow = hSbrEnvFrame->v_freqFollow;

  INT *length_v_bordFollow = &hSbrEnvFrame->length_v_bordFollow;
  INT *length_v_freqFollow = &hSbrEnvFrame->length_v_freqFollow;
  INT *length_v_bord = &hSbrEnvFrame->length_v_bord;
  INT *length_v_freq = &hSbrEnvFrame->length_v_freq;
  INT *spreadFlag = &hSbrEnvFrame->spreadFlag;
  INT *i_tranFollow = &hSbrEnvFrame->i_tranFollow;
  INT *i_fillFollow = &hSbrEnvFrame->i_fillFollow;
  FRAME_CLASS *frameClassOld = &hSbrEnvFrame->frameClassOld;
  FRAME_CLASS frameClass = FIXFIX;

  INT allowSpread = hSbrEnvFrame->allowSpread;
  INT numEnvStatic = hSbrEnvFrame->numEnvStatic;
  INT staticFraming = hSbrEnvFrame->staticFraming;
  INT dmin = hSbrEnvFrame->dmin;
  INT dmax = hSbrEnvFrame->dmax;

  INT bufferFrameStart = hSbrEnvFrame->SbrGrid.bufferFrameStart;
  INT numberTimeSlots = hSbrEnvFrame->SbrGrid.numberTimeSlots;
  INT frameMiddleSlot = hSbrEnvFrame->frameMiddleSlot;

  INT tranPos = v_transient_info[0];
  INT tranFlag = v_transient_info[1];

  const int *v_tuningSegm = v_tuning;
  const int *v_tuningFreq = v_tuning + 3;

  hSbrEnvFrame->v_tuningSegm = v_tuningSegm;

  if (ldGrid) {
    /* in case there was a transient at the very end of the previous frame,
     * start with a transient envelope */
    if (!tranFlag && v_transient_info_pre[1] &&
        (numberTimeSlots - v_transient_info_pre[0] < minFrameTranDistance)) {
      tranFlag = 1;
      tranPos = 0;
    }
  }

  /*
   * Synopsis:
   *
   * The frame generator creates the time-/frequency-grid for one SBR frame.
   * Input signals are provided by the transient detector and the frame
   * splitter (transientDetectNew() & FrameSplitter() in tran_det.c).  The
   * framing is controlled by adjusting tuning parameters stored in
   * FRAME_GEN_TUNING.  The parameter values are dependent on frame lengths
   * and bitrates, and may in the future be signal dependent.
   *
   * The envelope borders are stored for frame generator internal use in
   * aBorders.  The contents of aBorders represent positions along the time
   * axis given in the figures in fram_gen.h (the "frame-generator" rows).
   * The unit is "time slot".  The figures in fram_gen.h also define the
   * detection ranges for the transient detector.  For every border in
   * aBorders, there is a corresponding entry in aFreqRes, which defines the
   * frequency resolution of the envelope following (delimited by) the
   * border.
   *
   * When no transients are present, FIXFIX class frames are used.  The
   * frame splitter decides whether to use one or two envelopes in the
   * FIXFIX frame.  "Sparse transients" (separated by a few frames without
   * transients) are handeled by [FIXVAR, VARFIX] pairs or (depending on
   * tuning and transient position relative the nominal frame boundaries)
   * by [FIXVAR, VARVAR, VARFIX] triples.  "Tight transients" (in
   * consecutive frames) are handeled by [..., VARVAR, VARVAR, ...]
   * sequences.
   *
   * The generator assumes that transients are "sparse", and designs
   * borders for [FIXVAR, VARFIX] pairs right away, where the first frame
   * corresponds to the present frame.  At the next call of the generator
   * it is known whether the transient actually is "sparse" or not.  If
   * 'yes', the already calculated VARFIX borders are used.  If 'no', new
   * borders, meeting the requirements of the "tight" transient, are
   * calculated.
   *
   * The generator produces two outputs:  A "clear-text bitstream" stored in
   * SBR_GRID, and a straight-forward representation of the grid stored in
   * SBR_FRAME_INFO.  The former is subsequently converted to the actual
   * bitstream sbr_grid() (encodeSbrGrid() in bit_sbr.c).  The latter is
   * used by other encoder functions, such as the envelope estimator
   * (calculateSbrEnvelope() in env_est.c) and the noise floor and missing
   * harmonics detector (TonCorrParamExtr() in nf_est.c).
   */

  if (staticFraming) {
    /*--------------------------------------------------------------------------
      Ignore transient detector
    ---------------------------------------------------------------------------*/

    frameClass = FIXFIX;
    numEnv = numEnvStatic;   /* {1,2,4,8} */
    *frameClassOld = FIXFIX; /* for change to dyn */
    hSbrEnvFrame->SbrGrid.bs_num_env = numEnv;
    hSbrEnvFrame->SbrGrid.frameClass = frameClass;
  } else {
    /*--------------------------------------------------------------------------
      Calculate frame class to use
    ---------------------------------------------------------------------------*/
    if (rightBorderFIX) {
      tranFlag = 0;
      *spreadFlag = 0;
    }
    calcFrameClass(&frameClass, frameClassOld, tranFlag, spreadFlag);

    /* patch for new frame class FIXFIXonly for AAC LD */
    if (tranFlag && ldGrid) {
      frameClass = FIXFIXonly;
      *frameClassOld = FIXFIX;
    }

    /*
     * every transient is processed below by inserting
     *
     * - one border at the onset of the transient
     * - one or more "decay borders" (after the onset of the transient)
     * - optionally one "attack border" (before the onset of the transient)
     *
     * those borders are referred to as "mandatory borders" and are
     * defined by the 'segmentLength' array in FRAME_GEN_TUNING
     *
     * the frequency resolutions of the corresponding envelopes are
     * defined by the 'segmentRes' array in FRAME_GEN_TUNING
     */

    /*--------------------------------------------------------------------------
      Design frame (or follow-up old design)
    ---------------------------------------------------------------------------*/
    if (tranFlag) {
      /* Always for FixVar, often but not always for VarVar */

      /*--------------------------------------------------------------------------
        Design part of T/F-grid around the new transient
      ---------------------------------------------------------------------------*/

      tranPosInternal =
          frameMiddleSlot + tranPos + bufferFrameStart; /* FH 00-06-26 */
      /*
        add mandatory borders around transient
      */

      fillFrameTran(v_tuningSegm, v_tuningFreq, tranPosInternal, v_bord,
                    length_v_bord, v_freq, length_v_freq, &bmin, &bmax);

      /* make sure we stay within the maximum SBR frame overlap */
      fmax = calcFillLengthMax(tranPos, numberTimeSlots);
    }

    switch (frameClass) {
      case FIXFIXonly:
        FDK_ASSERT(ldGrid);
        tranPosInternal = tranPos;
        generateFixFixOnly(&(hSbrEnvFrame->SbrFrameInfo),
                           &(hSbrEnvFrame->SbrGrid), tranPosInternal,
                           numberTimeSlots, hSbrEnvFrame->fResTransIsLow);

        return &(hSbrEnvFrame->SbrFrameInfo);

      case FIXVAR:

        /*--------------------------------------------------------------------------
           Design remaining parts of T/F-grid (assuming next frame is VarFix)
        ---------------------------------------------------------------------------*/

        /*--------------------------------------------------------------------------
          Fill region before new transient:
        ---------------------------------------------------------------------------*/
        fillFramePre(dmax, v_bord, length_v_bord, v_freq, length_v_freq, bmin,
                     bmin - bufferFrameStart); /* FH 00-06-26 */

        /*--------------------------------------------------------------------------
          Fill region after new transient:
        ---------------------------------------------------------------------------*/
        fillFramePost(&parts, &d, dmax, v_bord, length_v_bord, v_freq,
                      length_v_freq, bmax, bufferFrameStart, numberTimeSlots,
                      fmax);

        /*--------------------------------------------------------------------------
          Take care of special case:
        ---------------------------------------------------------------------------*/
        if (parts == 1 && d < dmin) /* no fill, short last envelope */
          specialCase(spreadFlag, allowSpread, v_bord, length_v_bord, v_freq,
                      length_v_freq, &parts, d);

        /*--------------------------------------------------------------------------
          Calculate common border (split-point)
        ---------------------------------------------------------------------------*/
        calcCmonBorder(&i_cmon, &i_tran, v_bord, length_v_bord, tranPosInternal,
                       bufferFrameStart, numberTimeSlots); /* FH 00-06-26 */

        /*--------------------------------------------------------------------------
          Extract data for proper follow-up in next frame
        ---------------------------------------------------------------------------*/
        keepForFollowUp(v_bordFollow, length_v_bordFollow, v_freqFollow,
                        length_v_freqFollow, i_tranFollow, i_fillFollow, v_bord,
                        length_v_bord, v_freq, i_cmon, i_tran, parts,
                        numberTimeSlots); /* FH 00-06-26 */

        /*--------------------------------------------------------------------------
          Calculate control signal
        ---------------------------------------------------------------------------*/
        calcCtrlSignal(&hSbrEnvFrame->SbrGrid, frameClass, v_bord,
                       *length_v_bord, v_freq, *length_v_freq, i_cmon, i_tran,
                       *spreadFlag, DC);
        break;
      case VARFIX:
        /*--------------------------------------------------------------------------
          Follow-up old transient - calculate control signal
        ---------------------------------------------------------------------------*/
        calcCtrlSignal(&hSbrEnvFrame->SbrGrid, frameClass, v_bordFollow,
                       *length_v_bordFollow, v_freqFollow, *length_v_freqFollow,
                       DC, *i_tranFollow, *spreadFlag, DC);
        break;
      case VARVAR:
        if (*spreadFlag) { /* spread across three frames */
          /*--------------------------------------------------------------------------
            Follow-up old transient - calculate control signal
          ---------------------------------------------------------------------------*/
          calcCtrlSignal(&hSbrEnvFrame->SbrGrid, frameClass, v_bordFollow,
                         *length_v_bordFollow, v_freqFollow,
                         *length_v_freqFollow, DC, *i_tranFollow, *spreadFlag,
                         DC);

          *spreadFlag = 0;

          /*--------------------------------------------------------------------------
            Extract data for proper follow-up in next frame
          ---------------------------------------------------------------------------*/
          v_bordFollow[0] = hSbrEnvFrame->SbrGrid.bs_abs_bord_1 -
                            numberTimeSlots; /* FH 00-06-26 */
          v_freqFollow[0] = 1;
          *length_v_bordFollow = 1;
          *length_v_freqFollow = 1;

          *i_tranFollow = -DC;
          *i_fillFollow = -DC;
        } else {
          /*--------------------------------------------------------------------------
            Design remaining parts of T/F-grid (assuming next frame is VarFix)
            adapt or fill region before new transient:
          ---------------------------------------------------------------------------*/
          fillFrameInter(&nL, v_tuningSegm, v_bord, length_v_bord, bmin, v_freq,
                         length_v_freq, v_bordFollow, length_v_bordFollow,
                         v_freqFollow, length_v_freqFollow, *i_fillFollow, dmin,
                         dmax, numberTimeSlots);

          /*--------------------------------------------------------------------------
            Fill after transient:
          ---------------------------------------------------------------------------*/
          fillFramePost(&parts, &d, dmax, v_bord, length_v_bord, v_freq,
                        length_v_freq, bmax, bufferFrameStart, numberTimeSlots,
                        fmax);

          /*--------------------------------------------------------------------------
            Take care of special case:
          ---------------------------------------------------------------------------*/
          if (parts == 1 && d < dmin) /*% no fill, short last envelope */
            specialCase(spreadFlag, allowSpread, v_bord, length_v_bord, v_freq,
                        length_v_freq, &parts, d);

          /*--------------------------------------------------------------------------
            Calculate common border (split-point)
          ---------------------------------------------------------------------------*/
          calcCmonBorder(&i_cmon, &i_tran, v_bord, length_v_bord,
                         tranPosInternal, bufferFrameStart, numberTimeSlots);

          /*--------------------------------------------------------------------------
            Extract data for proper follow-up in next frame
          ---------------------------------------------------------------------------*/
          keepForFollowUp(v_bordFollow, length_v_bordFollow, v_freqFollow,
                          length_v_freqFollow, i_tranFollow, i_fillFollow,
                          v_bord, length_v_bord, v_freq, i_cmon, i_tran, parts,
                          numberTimeSlots);

          /*--------------------------------------------------------------------------
            Calculate control signal
          ---------------------------------------------------------------------------*/
          calcCtrlSignal(&hSbrEnvFrame->SbrGrid, frameClass, v_bord,
                         *length_v_bord, v_freq, *length_v_freq, i_cmon, i_tran,
                         0, nL);
        }
        break;
      case FIXFIX:
        if (tranPos == 0)
          numEnv = 1;
        else
          numEnv = 2;

        hSbrEnvFrame->SbrGrid.bs_num_env = numEnv;
        hSbrEnvFrame->SbrGrid.frameClass = frameClass;

        break;
      default:
        FDK_ASSERT(0);
    }
  }

  /*-------------------------------------------------------------------------
    Convert control signal to frame info struct
  ---------------------------------------------------------------------------*/
  ctrlSignal2FrameInfo(&hSbrEnvFrame->SbrGrid, &hSbrEnvFrame->SbrFrameInfo,
                       hSbrEnvFrame->freq_res_fixfix);

  return &hSbrEnvFrame->SbrFrameInfo;
}

/***************************************************************************/
/*!
  \brief    Gnerates frame info for FIXFIXonly frame class used for low delay
 version

  \return   nothing
 ****************************************************************************/
static void generateFixFixOnly(HANDLE_SBR_FRAME_INFO hSbrFrameInfo,
                               HANDLE_SBR_GRID hSbrGrid, int tranPosInternal,
                               int numberTimeSlots, UCHAR fResTransIsLow) {
  int nEnv, i, k = 0, tranIdx;
  const int *pTable = NULL;
  const FREQ_RES *freqResTable = NULL;

  switch (numberTimeSlots) {
    case 8: {
      pTable = envelopeTable_8[tranPosInternal];
    }
      freqResTable = freqRes_table_8;
      break;
    case 15:
      pTable = envelopeTable_15[tranPosInternal];
      freqResTable = freqRes_table_16;
      break;
    case 16:
      pTable = envelopeTable_16[tranPosInternal];
      freqResTable = freqRes_table_16;
      break;
  }

  /* look number of envolpes in table */
  nEnv = pTable[0];
  /* look up envolpe distribution in table */
  for (i = 1; i < nEnv; i++) hSbrFrameInfo->borders[i] = pTable[i + 2];

  /* open and close frame border */
  hSbrFrameInfo->borders[0] = 0;
  hSbrFrameInfo->borders[nEnv] = numberTimeSlots;

  /* adjust segment-frequency-resolution according to the segment-length */
  for (i = 0; i < nEnv; i++) {
    k = hSbrFrameInfo->borders[i + 1] - hSbrFrameInfo->borders[i];
    if (!fResTransIsLow)
      hSbrFrameInfo->freqRes[i] = freqResTable[k];
    else
      hSbrFrameInfo->freqRes[i] = FREQ_RES_LOW;

    hSbrGrid->v_f[i] = hSbrFrameInfo->freqRes[i];
  }

  hSbrFrameInfo->nEnvelopes = nEnv;
  hSbrFrameInfo->shortEnv = pTable[2];
  /* transient idx */
  tranIdx = pTable[1];

  /* add noise floors */
  hSbrFrameInfo->bordersNoise[0] = 0;
  hSbrFrameInfo->bordersNoise[1] =
      hSbrFrameInfo->borders[tranIdx ? tranIdx : 1];
  hSbrFrameInfo->bordersNoise[2] = numberTimeSlots;
  hSbrFrameInfo->nNoiseEnvelopes = 2;

  hSbrGrid->frameClass = FIXFIXonly;
  hSbrGrid->bs_abs_bord = tranPosInternal;
  hSbrGrid->bs_num_env = nEnv;
}

/*******************************************************************************
 Functionname:  FDKsbrEnc_initFrameInfoGenerator
 *******************************************************************************

 Description:

 Arguments:   hSbrEnvFrame  - pointer to sbr envelope handle
              allowSpread   - commandline parameter
              numEnvStatic  - commandline parameter
              staticFraming - commandline parameter

 Return:      none

*******************************************************************************/
void FDKsbrEnc_initFrameInfoGenerator(HANDLE_SBR_ENVELOPE_FRAME hSbrEnvFrame,
                                      INT allowSpread, INT numEnvStatic,
                                      INT staticFraming, INT timeSlots,
                                      const FREQ_RES *freq_res_fixfix,
                                      UCHAR fResTransIsLow,
                                      INT ldGrid) { /* FH 00-06-26 */

  FDKmemclear(hSbrEnvFrame, sizeof(SBR_ENVELOPE_FRAME));

  /* Initialisation */
  hSbrEnvFrame->frameClassOld = FIXFIX;
  hSbrEnvFrame->spreadFlag = 0;

  hSbrEnvFrame->allowSpread = allowSpread;
  hSbrEnvFrame->numEnvStatic = numEnvStatic;
  hSbrEnvFrame->staticFraming = staticFraming;
  hSbrEnvFrame->freq_res_fixfix[0] = freq_res_fixfix[0];
  hSbrEnvFrame->freq_res_fixfix[1] = freq_res_fixfix[1];
  hSbrEnvFrame->fResTransIsLow = fResTransIsLow;

  hSbrEnvFrame->length_v_bord = 0;
  hSbrEnvFrame->length_v_bordFollow = 0;

  hSbrEnvFrame->length_v_freq = 0;
  hSbrEnvFrame->length_v_freqFollow = 0;

  hSbrEnvFrame->i_tranFollow = 0;
  hSbrEnvFrame->i_fillFollow = 0;

  hSbrEnvFrame->SbrGrid.numberTimeSlots = timeSlots;

  if (ldGrid) {
    /*case CODEC_AACLD:*/
    hSbrEnvFrame->dmin = 2;
    hSbrEnvFrame->dmax = 16;
    hSbrEnvFrame->frameMiddleSlot = FRAME_MIDDLE_SLOT_512LD;
    hSbrEnvFrame->SbrGrid.bufferFrameStart = 0;
  } else
    switch (timeSlots) {
      case NUMBER_TIME_SLOTS_1920:
        hSbrEnvFrame->dmin = 4;
        hSbrEnvFrame->dmax = 12;
        hSbrEnvFrame->SbrGrid.bufferFrameStart = 0;
        hSbrEnvFrame->frameMiddleSlot = FRAME_MIDDLE_SLOT_1920;
        break;
      case NUMBER_TIME_SLOTS_2048:
        hSbrEnvFrame->dmin = 4;
        hSbrEnvFrame->dmax = 12;
        hSbrEnvFrame->SbrGrid.bufferFrameStart = 0;
        hSbrEnvFrame->frameMiddleSlot = FRAME_MIDDLE_SLOT_2048;
        break;
      case NUMBER_TIME_SLOTS_1152:
        hSbrEnvFrame->dmin = 2;
        hSbrEnvFrame->dmax = 8;
        hSbrEnvFrame->SbrGrid.bufferFrameStart = 0;
        hSbrEnvFrame->frameMiddleSlot = FRAME_MIDDLE_SLOT_1152;
        break;
      case NUMBER_TIME_SLOTS_2304:
        hSbrEnvFrame->dmin = 4;
        hSbrEnvFrame->dmax = 15;
        hSbrEnvFrame->SbrGrid.bufferFrameStart = 0;
        hSbrEnvFrame->frameMiddleSlot = FRAME_MIDDLE_SLOT_2304;
        break;
      default:
        FDK_ASSERT(0);
    }
}

/*******************************************************************************
 Functionname:  fillFrameTran
 *******************************************************************************

 Description:  Add mandatory borders, as described by the tuning vector
               and the current transient position

 Arguments:
      modified:
              v_bord        - int pointer to v_bord vector
              length_v_bord - length of v_bord vector
              v_freq        - int pointer to v_freq vector
              length_v_freq - length of v_freq vector
              bmin          - int pointer to bmin (call by reference)
              bmax          - int pointer to bmax (call by reference)
      not modified:
              tran          - position of transient
              v_tuningSegm  - int pointer to v_tuningSegm vector
              v_tuningFreq  - int pointer to v_tuningFreq vector

 Return:      none

*******************************************************************************/
static void fillFrameTran(
    const int *v_tuningSegm, /*!< tuning: desired segment lengths */
    const int *v_tuningFreq, /*!< tuning: desired frequency resolutions */
    int tran,                /*!< input : position of transient */
    int *v_bord,             /*!< memNew: borders */
    int *length_v_bord,      /*!< memNew: # borders */
    int *v_freq,             /*!< memNew: frequency resolutions */
    int *length_v_freq,      /*!< memNew: # frequency resolutions */
    int *bmin,               /*!< hlpNew: first mandatory border */
    int *bmax                /*!< hlpNew: last  mandatory border */
) {
  int bord, i;

  *length_v_bord = 0;
  *length_v_freq = 0;

  /* add attack env leading border (optional) */
  if (v_tuningSegm[0]) {
    /* v_bord = [(Ba)] start of attack env */
    FDKsbrEnc_AddRight(v_bord, length_v_bord, (tran - v_tuningSegm[0]));

    /* v_freq = [(Fa)] res of attack env */
    FDKsbrEnc_AddRight(v_freq, length_v_freq, v_tuningFreq[0]);
  }

  /* add attack env trailing border/first decay env leading border */
  bord = tran;
  FDKsbrEnc_AddRight(v_bord, length_v_bord, tran); /* v_bord = [(Ba),Bd1] */

  /* add first decay env trailing border/2:nd decay env leading border */
  if (v_tuningSegm[1]) {
    bord += v_tuningSegm[1];

    /* v_bord = [(Ba),Bd1,Bd2] */
    FDKsbrEnc_AddRight(v_bord, length_v_bord, bord);

    /* v_freq = [(Fa),Fd1] */
    FDKsbrEnc_AddRight(v_freq, length_v_freq, v_tuningFreq[1]);
  }

  /* add 2:nd decay env trailing border (optional) */
  if (v_tuningSegm[2] != 0) {
    bord += v_tuningSegm[2];

    /* v_bord = [(Ba),Bd1, Bd2,(Bd3)] */
    FDKsbrEnc_AddRight(v_bord, length_v_bord, bord);

    /* v_freq = [(Fa),Fd1,(Fd2)] */
    FDKsbrEnc_AddRight(v_freq, length_v_freq, v_tuningFreq[2]);
  }

  /*  v_freq = [(Fa),Fd1,(Fd2),1] */
  FDKsbrEnc_AddRight(v_freq, length_v_freq, 1);

  /*  calc min and max values of mandatory borders */
  *bmin = v_bord[0];
  for (i = 0; i < *length_v_bord; i++)
    if (v_bord[i] < *bmin) *bmin = v_bord[i];

  *bmax = v_bord[0];
  for (i = 0; i < *length_v_bord; i++)
    if (v_bord[i] > *bmax) *bmax = v_bord[i];
}

/*******************************************************************************
 Functionname:  fillFramePre
 *******************************************************************************

 Description: Add borders before mandatory borders, if needed

 Arguments:
       modified:
              v_bord        - int pointer to v_bord vector
              length_v_bord - length of v_bord vector
              v_freq        - int pointer to v_freq vector
              length_v_freq - length of v_freq vector
       not modified:
              dmax          - int value
              bmin          - int value
              rest          - int value

 Return:      none

*******************************************************************************/
static void fillFramePre(INT dmax, INT *v_bord, INT *length_v_bord, INT *v_freq,
                         INT *length_v_freq, INT bmin, INT rest) {
  /*
    input state:
    v_bord = [(Ba),Bd1, Bd2 ,(Bd3)]
    v_freq = [(Fa),Fd1,(Fd2),1 ]
  */

  INT parts, d, j, S, s = 0, segm, bord;

  /*
    start with one envelope
  */

  parts = 1;
  d = rest;

  /*
    calc # of additional envelopes and corresponding lengths
  */

  while (d > dmax) {
    parts++;

    segm = rest / parts;
    S = (segm - 2) >> 1;
    s = fixMin(8, 2 * S + 2);
    d = rest - (parts - 1) * s;
  }

  /*
    add borders before mandatory borders
  */

  bord = bmin;

  for (j = 0; j <= parts - 2; j++) {
    bord = bord - s;

    /* v_bord = [...,(Bf),(Ba),Bd1, Bd2 ,(Bd3)] */
    FDKsbrEnc_AddLeft(v_bord, length_v_bord, bord);

    /* v_freq = [...,(1 ),(Fa),Fd1,(Fd2), 1   ] */
    FDKsbrEnc_AddLeft(v_freq, length_v_freq, 1);
  }
}

/***************************************************************************/
/*!
  \brief Overlap control

  Calculate max length of trailing fill segments, such that we always get a
  border within the frame overlap region

  \return void

****************************************************************************/
static int calcFillLengthMax(
    int tranPos,        /*!< input : transient position (ref: tran det) */
    int numberTimeSlots /*!< input : number of timeslots */
) {
  int fmax;

  /*
    calculate transient position within envelope buffer
  */
  switch (numberTimeSlots) {
    case NUMBER_TIME_SLOTS_2048:
      if (tranPos < 4)
        fmax = 6;
      else if (tranPos == 4 || tranPos == 5)
        fmax = 4;
      else
        fmax = 8;
      break;

    case NUMBER_TIME_SLOTS_1920:
      if (tranPos < 4)
        fmax = 5;
      else if (tranPos == 4 || tranPos == 5)
        fmax = 3;
      else
        fmax = 7;
      break;

    default:
      fmax = 8;
      break;
  }

  return fmax;
}

/*******************************************************************************
 Functionname:  fillFramePost
 *******************************************************************************

 Description: -Add borders after mandatory borders, if needed
               Make a preliminary design of next frame,
               assuming no transient is present there

 Arguments:
       modified:
              parts         - int pointer to parts (call by reference)
              d             - int pointer to d (call by reference)
              v_bord        - int pointer to v_bord vector
              length_v_bord - length of v_bord vector
              v_freq        - int pointer to v_freq vector
              length_v_freq - length of v_freq vector
        not modified:
              bmax          - int value
              dmax          - int value

 Return:      none

*******************************************************************************/
static void fillFramePost(INT *parts, INT *d, INT dmax, INT *v_bord,
                          INT *length_v_bord, INT *v_freq, INT *length_v_freq,
                          INT bmax, INT bufferFrameStart, INT numberTimeSlots,
                          INT fmax) {
  INT j, rest, segm, S, s = 0, bord;

  /*
    input state:
    v_bord = [...,(Bf),(Ba),Bd1, Bd2 ,(Bd3)]
    v_freq = [...,(1 ),(Fa),Fd1,(Fd2),1    ]
  */

  rest = bufferFrameStart + 2 * numberTimeSlots - bmax;
  *d = rest;

  if (*d > 0) {
    *parts = 1; /* start with one envelope */

    /* calc # of additional envelopes and corresponding lengths */

    while (*d > dmax) {
      *parts = *parts + 1;

      segm = rest / (*parts);
      S = (segm - 2) >> 1;
      s = fixMin(fmax, 2 * S + 2);
      *d = rest - (*parts - 1) * s;
    }

    /* add borders after mandatory borders */

    bord = bmax;
    for (j = 0; j <= *parts - 2; j++) {
      bord += s;

      /* v_bord =  [...,(Bf),(Ba),Bd1, Bd2 ,(Bd3),(Bf)] */
      FDKsbrEnc_AddRight(v_bord, length_v_bord, bord);

      /* v_freq =  [...,(1 ),(Fa),Fd1,(Fd2), 1   , 1! ,1] */
      FDKsbrEnc_AddRight(v_freq, length_v_freq, 1);
    }
  } else {
    *parts = 1;

    /* remove last element from v_bord and v_freq */

    *length_v_bord = *length_v_bord - 1;
    *length_v_freq = *length_v_freq - 1;
  }
}

/*******************************************************************************
 Functionname:  fillFrameInter
 *******************************************************************************

 Description:

 Arguments:   nL                  -
              v_tuningSegm        -
              v_bord              -
              length_v_bord       -
              bmin                -
              v_freq              -
              length_v_freq       -
              v_bordFollow        -
              length_v_bordFollow -
              v_freqFollow        -
              length_v_freqFollow -
              i_fillFollow        -
              dmin                -
              dmax                -

 Return:      none

*******************************************************************************/
static void fillFrameInter(INT *nL, const int *v_tuningSegm, INT *v_bord,
                           INT *length_v_bord, INT bmin, INT *v_freq,
                           INT *length_v_freq, INT *v_bordFollow,
                           INT *length_v_bordFollow, INT *v_freqFollow,
                           INT *length_v_freqFollow, INT i_fillFollow, INT dmin,
                           INT dmax, INT numberTimeSlots) {
  INT middle, b_new, numBordFollow, bordMaxFollow, i;

  if (numberTimeSlots != NUMBER_TIME_SLOTS_1152) {
    /* % remove fill borders: */
    if (i_fillFollow >= 1) {
      *length_v_bordFollow = i_fillFollow;
      *length_v_freqFollow = i_fillFollow;
    }

    numBordFollow = *length_v_bordFollow;
    bordMaxFollow = v_bordFollow[numBordFollow - 1];

    /* remove even more borders if needed */
    middle = bmin - bordMaxFollow;
    while (middle < 0) {
      numBordFollow--;
      bordMaxFollow = v_bordFollow[numBordFollow - 1];
      middle = bmin - bordMaxFollow;
    }

    *length_v_bordFollow = numBordFollow;
    *length_v_freqFollow = numBordFollow;
    *nL = numBordFollow - 1;

    b_new = *length_v_bord;

    if (middle <= dmax) {
      if (middle >= dmin) { /* concatenate */
        FDKsbrEnc_AddVecLeft(v_bord, length_v_bord, v_bordFollow,
                             *length_v_bordFollow);
        FDKsbrEnc_AddVecLeft(v_freq, length_v_freq, v_freqFollow,
                             *length_v_freqFollow);
      }

      else {
        if (v_tuningSegm[0] != 0) { /* remove one new border and concatenate */
          *length_v_bord = b_new - 1;
          FDKsbrEnc_AddVecLeft(v_bord, length_v_bord, v_bordFollow,
                               *length_v_bordFollow);

          *length_v_freq = b_new - 1;
          FDKsbrEnc_AddVecLeft(v_freq + 1, length_v_freq, v_freqFollow,
                               *length_v_freqFollow);
        } else {
          if (*length_v_bordFollow >
              1) { /* remove one old border and concatenate */
            FDKsbrEnc_AddVecLeft(v_bord, length_v_bord, v_bordFollow,
                                 *length_v_bordFollow - 1);
            FDKsbrEnc_AddVecLeft(v_freq, length_v_freq, v_freqFollow,
                                 *length_v_bordFollow - 1);

            *nL = *nL - 1;
          } else { /* remove new "transient" border and concatenate */

            for (i = 0; i < *length_v_bord - 1; i++) v_bord[i] = v_bord[i + 1];

            for (i = 0; i < *length_v_freq - 1; i++) v_freq[i] = v_freq[i + 1];

            *length_v_bord = b_new - 1;
            *length_v_freq = b_new - 1;

            FDKsbrEnc_AddVecLeft(v_bord, length_v_bord, v_bordFollow,
                                 *length_v_bordFollow);
            FDKsbrEnc_AddVecLeft(v_freq, length_v_freq, v_freqFollow,
                                 *length_v_freqFollow);
          }
        }
      }
    } else { /* middle > dmax */

      fillFramePre(dmax, v_bord, length_v_bord, v_freq, length_v_freq, bmin,
                   middle);
      FDKsbrEnc_AddVecLeft(v_bord, length_v_bord, v_bordFollow,
                           *length_v_bordFollow);
      FDKsbrEnc_AddVecLeft(v_freq, length_v_freq, v_freqFollow,
                           *length_v_freqFollow);
    }

  } else { /* numberTimeSlots==NUMBER_TIME_SLOTS_1152 */

    INT l, m;

    /*------------------------------------------------------------------------
      remove fill borders
      ------------------------------------------------------------------------*/
    if (i_fillFollow >= 1) {
      *length_v_bordFollow = i_fillFollow;
      *length_v_freqFollow = i_fillFollow;
    }

    numBordFollow = *length_v_bordFollow;
    bordMaxFollow = v_bordFollow[numBordFollow - 1];

    /*------------------------------------------------------------------------
      remove more borders if necessary to eliminate overlap
      ------------------------------------------------------------------------*/

    /* check for overlap */
    middle = bmin - bordMaxFollow;

    /* intervals:
       i)             middle <  0     : overlap, must remove borders
       ii)       0 <= middle <  dmin  : no overlap but too tight, must remove
       borders iii)   dmin <= middle <= dmax  : ok, just concatenate iv)    dmax
       <= middle          : too wide, must add borders
     */

    /* first remove old non-fill-borders... */
    while (middle < 0) {
      /* ...but don't remove all of them */
      if (numBordFollow == 1) break;

      numBordFollow--;
      bordMaxFollow = v_bordFollow[numBordFollow - 1];
      middle = bmin - bordMaxFollow;
    }

    /* if this isn't enough, remove new non-fill borders */
    if (middle < 0) {
      for (l = 0, m = 0; l < *length_v_bord; l++) {
        if (v_bord[l] > bordMaxFollow) {
          v_bord[m] = v_bord[l];
          v_freq[m] = v_freq[l];
          m++;
        }
      }

      *length_v_bord = l;
      *length_v_freq = l;

      bmin = v_bord[0];
    }

    /*------------------------------------------------------------------------
      update modified follow-up data
      ------------------------------------------------------------------------*/

    *length_v_bordFollow = numBordFollow;
    *length_v_freqFollow = numBordFollow;

    /* left relative borders correspond to follow-up */
    *nL = numBordFollow - 1;

    /*------------------------------------------------------------------------
      take care of intervals ii through iv
      ------------------------------------------------------------------------*/

    /* now middle should be >= 0 */
    middle = bmin - bordMaxFollow;

    if (middle <= dmin) /* (ii) */
    {
      b_new = *length_v_bord;

      if (v_tuningSegm[0] != 0) {
        /* remove new "luxury" border and concatenate */
        *length_v_bord = b_new - 1;
        FDKsbrEnc_AddVecLeft(v_bord, length_v_bord, v_bordFollow,
                             *length_v_bordFollow);

        *length_v_freq = b_new - 1;
        FDKsbrEnc_AddVecLeft(v_freq + 1, length_v_freq, v_freqFollow,
                             *length_v_freqFollow);

      } else if (*length_v_bordFollow > 1) {
        /* remove old border and concatenate */
        FDKsbrEnc_AddVecLeft(v_bord, length_v_bord, v_bordFollow,
                             *length_v_bordFollow - 1);
        FDKsbrEnc_AddVecLeft(v_freq, length_v_freq, v_freqFollow,
                             *length_v_bordFollow - 1);

        *nL = *nL - 1;
      } else {
        /* remove new border and concatenate */
        for (i = 0; i < *length_v_bord - 1; i++) v_bord[i] = v_bord[i + 1];

        for (i = 0; i < *length_v_freq - 1; i++) v_freq[i] = v_freq[i + 1];

        *length_v_bord = b_new - 1;
        *length_v_freq = b_new - 1;

        FDKsbrEnc_AddVecLeft(v_bord, length_v_bord, v_bordFollow,
                             *length_v_bordFollow);
        FDKsbrEnc_AddVecLeft(v_freq, length_v_freq, v_freqFollow,
                             *length_v_freqFollow);
      }
    } else if ((middle >= dmin) && (middle <= dmax)) /* (iii) */
    {
      /* concatenate */
      FDKsbrEnc_AddVecLeft(v_bord, length_v_bord, v_bordFollow,
                           *length_v_bordFollow);
      FDKsbrEnc_AddVecLeft(v_freq, length_v_freq, v_freqFollow,
                           *length_v_freqFollow);

    } else /* (iv) */
    {
      fillFramePre(dmax, v_bord, length_v_bord, v_freq, length_v_freq, bmin,
                   middle);
      FDKsbrEnc_AddVecLeft(v_bord, length_v_bord, v_bordFollow,
                           *length_v_bordFollow);
      FDKsbrEnc_AddVecLeft(v_freq, length_v_freq, v_freqFollow,
                           *length_v_freqFollow);
    }
  }
}

/*******************************************************************************
 Functionname:  calcFrameClass
 *******************************************************************************

 Description:

 Arguments:  INT* frameClass, INT* frameClassOld, INT tranFlag, INT* spreadFlag)

 Return:      none

*******************************************************************************/
static void calcFrameClass(FRAME_CLASS *frameClass, FRAME_CLASS *frameClassOld,
                           INT tranFlag, INT *spreadFlag) {
  switch (*frameClassOld) {
    case FIXFIXonly:
    case FIXFIX:
      if (tranFlag)
        *frameClass = FIXVAR;
      else
        *frameClass = FIXFIX;
      break;
    case FIXVAR:
      if (tranFlag) {
        *frameClass = VARVAR;
        *spreadFlag = 0;
      } else {
        if (*spreadFlag)
          *frameClass = VARVAR;
        else
          *frameClass = VARFIX;
      }
      break;
    case VARFIX:
      if (tranFlag)
        *frameClass = FIXVAR;
      else
        *frameClass = FIXFIX;
      break;
    case VARVAR:
      if (tranFlag) {
        *frameClass = VARVAR;
        *spreadFlag = 0;
      } else {
        if (*spreadFlag)
          *frameClass = VARVAR;
        else
          *frameClass = VARFIX;
      }
      break;
  };

  *frameClassOld = *frameClass;
}

/*******************************************************************************
 Functionname:  specialCase
 *******************************************************************************

 Description:

 Arguments:   spreadFlag
              allowSpread
              v_bord
              length_v_bord
              v_freq
              length_v_freq
              parts
              d

 Return:      none

*******************************************************************************/
static void specialCase(INT *spreadFlag, INT allowSpread, INT *v_bord,
                        INT *length_v_bord, INT *v_freq, INT *length_v_freq,
                        INT *parts, INT d) {
  INT L;

  L = *length_v_bord;

  if (allowSpread) { /* add one "step 8" */
    *spreadFlag = 1;
    FDKsbrEnc_AddRight(v_bord, length_v_bord, v_bord[L - 1] + 8);
    FDKsbrEnc_AddRight(v_freq, length_v_freq, 1);
    (*parts)++;
  } else {
    if (d == 1) { /*  stretch one slot */
      *length_v_bord = L - 1;
      *length_v_freq = L - 1;
    } else {
      if ((v_bord[L - 1] - v_bord[L - 2]) > 2) { /* compress one quant step */
        v_bord[L - 1] = v_bord[L - 1] - 2;
        v_freq[*length_v_freq - 1] = 0; /* use low res for short segment */
      }
    }
  }
}

/*******************************************************************************
 Functionname:  calcCmonBorder
 *******************************************************************************

 Description:

 Arguments:   i_cmon
              i_tran
              v_bord
              length_v_bord
              tran

 Return:      none

*******************************************************************************/
static void calcCmonBorder(INT *i_cmon, INT *i_tran, INT *v_bord,
                           INT *length_v_bord, INT tran, INT bufferFrameStart,
                           INT numberTimeSlots) { /* FH 00-06-26 */
  INT i;

  for (i = 0; i < *length_v_bord; i++)
    if (v_bord[i] >= bufferFrameStart + numberTimeSlots) { /* FH 00-06-26 */
      *i_cmon = i;
      break;
    }

  /* keep track of transient: */
  for (i = 0; i < *length_v_bord; i++)
    if (v_bord[i] >= tran) {
      *i_tran = i;
      break;
    } else
      *i_tran = EMPTY;
}

/*******************************************************************************
 Functionname:  keepForFollowUp
 *******************************************************************************

 Description:

 Arguments:   v_bordFollow
              length_v_bordFollow
              v_freqFollow
              length_v_freqFollow
              i_tranFollow
              i_fillFollow
              v_bord
              length_v_bord
              v_freq
              i_cmon
              i_tran
              parts)

 Return:      none

*******************************************************************************/
static void keepForFollowUp(INT *v_bordFollow, INT *length_v_bordFollow,
                            INT *v_freqFollow, INT *length_v_freqFollow,
                            INT *i_tranFollow, INT *i_fillFollow, INT *v_bord,
                            INT *length_v_bord, INT *v_freq, INT i_cmon,
                            INT i_tran, INT parts,
                            INT numberTimeSlots) { /* FH 00-06-26 */
  INT L, i, j;

  L = *length_v_bord;

  (*length_v_bordFollow) = 0;
  (*length_v_freqFollow) = 0;

  for (j = 0, i = i_cmon; i < L; i++, j++) {
    v_bordFollow[j] = v_bord[i] - numberTimeSlots; /* FH 00-06-26 */
    v_freqFollow[j] = v_freq[i];
    (*length_v_bordFollow)++;
    (*length_v_freqFollow)++;
  }
  if (i_tran != EMPTY)
    *i_tranFollow = i_tran - i_cmon;
  else
    *i_tranFollow = EMPTY;
  *i_fillFollow = L - (parts - 1) - i_cmon;
}

/*******************************************************************************
 Functionname:  calcCtrlSignal
 *******************************************************************************

 Description:

 Arguments:   hSbrGrid
              frameClass
              v_bord
              length_v_bord
              v_freq
              length_v_freq
              i_cmon
              i_tran
              spreadFlag
              nL

 Return:      none

*******************************************************************************/
static void calcCtrlSignal(HANDLE_SBR_GRID hSbrGrid, FRAME_CLASS frameClass,
                           INT *v_bord, INT length_v_bord, INT *v_freq,
                           INT length_v_freq, INT i_cmon, INT i_tran,
                           INT spreadFlag, INT nL) {
  INT i, r, a, n, p, b, aL, aR, ntot, nmax, nR;

  INT *v_f = hSbrGrid->v_f;
  INT *v_fLR = hSbrGrid->v_fLR;
  INT *v_r = hSbrGrid->bs_rel_bord;
  INT *v_rL = hSbrGrid->bs_rel_bord_0;
  INT *v_rR = hSbrGrid->bs_rel_bord_1;

  INT length_v_r = 0;
  INT length_v_rR = 0;
  INT length_v_rL = 0;

  switch (frameClass) {
    case FIXVAR:
      /* absolute border: */

      a = v_bord[i_cmon];

      /* relative borders: */
      length_v_r = 0;
      i = i_cmon;

      while (i >= 1) {
        r = v_bord[i] - v_bord[i - 1];
        FDKsbrEnc_AddRight(v_r, &length_v_r, r);
        i--;
      }

      /*  number of relative borders: */
      n = length_v_r;

      /* freq res: */
      for (i = 0; i < i_cmon; i++) v_f[i] = v_freq[i_cmon - 1 - i];
      v_f[i_cmon] = 1;

      /* pointer: */
      p = (i_cmon >= i_tran && i_tran != EMPTY) ? (i_cmon - i_tran + 1) : (0);

      hSbrGrid->frameClass = frameClass;
      hSbrGrid->bs_abs_bord = a;
      hSbrGrid->n = n;
      hSbrGrid->p = p;

      break;
    case VARFIX:
      /* absolute border: */
      a = v_bord[0];

      /* relative borders: */
      length_v_r = 0;

      for (i = 1; i < length_v_bord; i++) {
        r = v_bord[i] - v_bord[i - 1];
        FDKsbrEnc_AddRight(v_r, &length_v_r, r);
      }

      /* number of relative borders: */
      n = length_v_r;

      /* freq res: */
      FDKmemcpy(v_f, v_freq, length_v_freq * sizeof(INT));

      /* pointer: */
      p = (i_tran >= 0 && i_tran != EMPTY) ? (i_tran + 1) : (0);

      hSbrGrid->frameClass = frameClass;
      hSbrGrid->bs_abs_bord = a;
      hSbrGrid->n = n;
      hSbrGrid->p = p;

      break;
    case VARVAR:
      if (spreadFlag) {
        /* absolute borders: */
        b = length_v_bord;

        aL = v_bord[0];
        aR = v_bord[b - 1];

        /* number of relative borders:    */
        ntot = b - 2;

        nmax = 2; /* n: {0,1,2} */
        if (ntot > nmax) {
          nL = nmax;
          nR = ntot - nmax;
        } else {
          nL = ntot;
          nR = 0;
        }

        /* relative borders: */
        length_v_rL = 0;
        for (i = 1; i <= nL; i++) {
          r = v_bord[i] - v_bord[i - 1];
          FDKsbrEnc_AddRight(v_rL, &length_v_rL, r);
        }

        length_v_rR = 0;
        i = b - 1;
        while (i >= b - nR) {
          r = v_bord[i] - v_bord[i - 1];
          FDKsbrEnc_AddRight(v_rR, &length_v_rR, r);
          i--;
        }

        /* pointer (only one due to constraint in frame info): */
        p = (i_tran > 0 && i_tran != EMPTY) ? (b - i_tran) : (0);

        /* freq res: */

        for (i = 0; i < b - 1; i++) v_fLR[i] = v_freq[i];
      } else {
        length_v_bord = i_cmon + 1;

        /* absolute borders: */
        b = length_v_bord;

        aL = v_bord[0];
        aR = v_bord[b - 1];

        /* number of relative borders:   */
        ntot = b - 2;
        nR = ntot - nL;

        /* relative borders: */
        length_v_rL = 0;
        for (i = 1; i <= nL; i++) {
          r = v_bord[i] - v_bord[i - 1];
          FDKsbrEnc_AddRight(v_rL, &length_v_rL, r);
        }

        length_v_rR = 0;
        i = b - 1;
        while (i >= b - nR) {
          r = v_bord[i] - v_bord[i - 1];
          FDKsbrEnc_AddRight(v_rR, &length_v_rR, r);
          i--;
        }

        /* pointer (only one due to constraint in frame info): */
        p = (i_cmon >= i_tran && i_tran != EMPTY) ? (i_cmon - i_tran + 1) : (0);

        /* freq res: */
        for (i = 0; i < b - 1; i++) v_fLR[i] = v_freq[i];
      }

      hSbrGrid->frameClass = frameClass;
      hSbrGrid->bs_abs_bord_0 = aL;
      hSbrGrid->bs_abs_bord_1 = aR;
      hSbrGrid->bs_num_rel_0 = nL;
      hSbrGrid->bs_num_rel_1 = nR;
      hSbrGrid->p = p;

      break;

    default:
      /* do nothing */
      break;
  }
}

/*******************************************************************************
 Functionname:  createDefFrameInfo
 *******************************************************************************

 Description: Copies the default (static) frameInfo structs to the frameInfo
              passed by reference; only used for FIXFIX frames

 Arguments:   hFrameInfo             - HANLDE_SBR_FRAME_INFO
              nEnv                   - INT
              nTimeSlots             - INT

 Return:      none; hSbrFrameInfo contains a copy of the default frameInfo

 Written:     Andreas Schneider
 Revised:
*******************************************************************************/
static void createDefFrameInfo(HANDLE_SBR_FRAME_INFO hSbrFrameInfo, INT nEnv,
                               INT nTimeSlots) {
  switch (nEnv) {
    case 1:
      switch (nTimeSlots) {
        case NUMBER_TIME_SLOTS_1920:
          FDKmemcpy(hSbrFrameInfo, &frameInfo1_1920, sizeof(SBR_FRAME_INFO));
          break;
        case NUMBER_TIME_SLOTS_2048:
          FDKmemcpy(hSbrFrameInfo, &frameInfo1_2048, sizeof(SBR_FRAME_INFO));
          break;
        case NUMBER_TIME_SLOTS_1152:
          FDKmemcpy(hSbrFrameInfo, &frameInfo1_1152, sizeof(SBR_FRAME_INFO));
          break;
        case NUMBER_TIME_SLOTS_2304:
          FDKmemcpy(hSbrFrameInfo, &frameInfo1_2304, sizeof(SBR_FRAME_INFO));
          break;
        case NUMBER_TIME_SLOTS_512LD:
          FDKmemcpy(hSbrFrameInfo, &frameInfo1_512LD, sizeof(SBR_FRAME_INFO));
          break;
        default:
          FDK_ASSERT(0);
      }
      break;
    case 2:
      switch (nTimeSlots) {
        case NUMBER_TIME_SLOTS_1920:
          FDKmemcpy(hSbrFrameInfo, &frameInfo2_1920, sizeof(SBR_FRAME_INFO));
          break;
        case NUMBER_TIME_SLOTS_2048:
          FDKmemcpy(hSbrFrameInfo, &frameInfo2_2048, sizeof(SBR_FRAME_INFO));
          break;
        case NUMBER_TIME_SLOTS_1152:
          FDKmemcpy(hSbrFrameInfo, &frameInfo2_1152, sizeof(SBR_FRAME_INFO));
          break;
        case NUMBER_TIME_SLOTS_2304:
          FDKmemcpy(hSbrFrameInfo, &frameInfo2_2304, sizeof(SBR_FRAME_INFO));
          break;
        case NUMBER_TIME_SLOTS_512LD:
          FDKmemcpy(hSbrFrameInfo, &frameInfo2_512LD, sizeof(SBR_FRAME_INFO));
          break;
        default:
          FDK_ASSERT(0);
      }
      break;
    case 4:
      switch (nTimeSlots) {
        case NUMBER_TIME_SLOTS_1920:
          FDKmemcpy(hSbrFrameInfo, &frameInfo4_1920, sizeof(SBR_FRAME_INFO));
          break;
        case NUMBER_TIME_SLOTS_2048:
          FDKmemcpy(hSbrFrameInfo, &frameInfo4_2048, sizeof(SBR_FRAME_INFO));
          break;
        case NUMBER_TIME_SLOTS_1152:
          FDKmemcpy(hSbrFrameInfo, &frameInfo4_1152, sizeof(SBR_FRAME_INFO));
          break;
        case NUMBER_TIME_SLOTS_2304:
          FDKmemcpy(hSbrFrameInfo, &frameInfo4_2304, sizeof(SBR_FRAME_INFO));
          break;
        case NUMBER_TIME_SLOTS_512LD:
          FDKmemcpy(hSbrFrameInfo, &frameInfo4_512LD, sizeof(SBR_FRAME_INFO));
          break;
        default:
          FDK_ASSERT(0);
      }
      break;
    default:
      FDK_ASSERT(0);
  }
}

/*******************************************************************************
 Functionname:  ctrlSignal2FrameInfo
 *******************************************************************************

 Description: Convert "clear-text" sbr_grid() to "frame info" used by the
              envelope and noise floor estimators.
              This is basically (except for "low level" calculations) the
              bitstream decoder defined in the MPEG-4 standard, sub clause
              4.6.18.3.3, Time / Frequency Grid.  See inline comments for
              explanation of the shorten and noise border algorithms.

 Arguments:   hSbrGrid - source
              hSbrFrameInfo - destination
              freq_res_fixfix - frequency resolution for FIXFIX frames

 Return:      void; hSbrFrameInfo contains the updated FRAME_INFO struct

*******************************************************************************/
static void ctrlSignal2FrameInfo(
    HANDLE_SBR_GRID hSbrGrid,            /* input : the grid handle       */
    HANDLE_SBR_FRAME_INFO hSbrFrameInfo, /* output: the frame info handle */
    FREQ_RES
        *freq_res_fixfix /* in/out: frequency resolution for FIXFIX frames */
) {
  INT frameSplit = 0;
  INT nEnv = 0, border = 0, i, k, p /*?*/;
  INT *v_r = hSbrGrid->bs_rel_bord;
  INT *v_f = hSbrGrid->v_f;

  FRAME_CLASS frameClass = hSbrGrid->frameClass;
  INT bufferFrameStart = hSbrGrid->bufferFrameStart;
  INT numberTimeSlots = hSbrGrid->numberTimeSlots;

  switch (frameClass) {
    case FIXFIX:
      createDefFrameInfo(hSbrFrameInfo, hSbrGrid->bs_num_env, numberTimeSlots);

      frameSplit = (hSbrFrameInfo->nEnvelopes > 1);
      for (i = 0; i < hSbrFrameInfo->nEnvelopes; i++) {
        hSbrGrid->v_f[i] = hSbrFrameInfo->freqRes[i] =
            freq_res_fixfix[frameSplit];
      }
      break;

    case FIXVAR:
    case VARFIX:
      nEnv = hSbrGrid->n + 1; /* read n [SBR_NUM_BITS bits] */ /*? snd*/
      FDK_ASSERT(nEnv <= MAX_ENVELOPES_FIXVAR_VARFIX);

      hSbrFrameInfo->nEnvelopes = nEnv;

      border = hSbrGrid->bs_abs_bord; /* read the absolute border */

      if (nEnv == 1)
        hSbrFrameInfo->nNoiseEnvelopes = 1;
      else
        hSbrFrameInfo->nNoiseEnvelopes = 2;

      break;

    default:
      /* do nothing */
      break;
  }

  switch (frameClass) {
    case FIXVAR:
      hSbrFrameInfo->borders[0] =
          bufferFrameStart; /* start-position of 1st envelope */

      hSbrFrameInfo->borders[nEnv] = border;

      for (k = 0, i = nEnv - 1; k < nEnv - 1; k++, i--) {
        border -= v_r[k];
        hSbrFrameInfo->borders[i] = border;
      }

      /* make either envelope nr. nEnv + 1 - p short; or don't shorten if p == 0
       */
      p = hSbrGrid->p;
      if (p == 0) {
        hSbrFrameInfo->shortEnv = 0;
      } else {
        hSbrFrameInfo->shortEnv = nEnv + 1 - p;
      }

      for (k = 0, i = nEnv - 1; k < nEnv; k++, i--) {
        hSbrFrameInfo->freqRes[i] = (FREQ_RES)v_f[k];
      }

      /* if either there is no short envelope or the last envelope is short...
       */
      if (p == 0 || p == 1) {
        hSbrFrameInfo->bordersNoise[1] = hSbrFrameInfo->borders[nEnv - 1];
      } else {
        hSbrFrameInfo->bordersNoise[1] =
            hSbrFrameInfo->borders[hSbrFrameInfo->shortEnv];
      }

      break;

    case VARFIX:
      /* in this case 'border' indicates the start of the 1st envelope */
      hSbrFrameInfo->borders[0] = border;

      for (k = 0; k < nEnv - 1; k++) {
        border += v_r[k];
        hSbrFrameInfo->borders[k + 1] = border;
      }

      hSbrFrameInfo->borders[nEnv] = bufferFrameStart + numberTimeSlots;

      p = hSbrGrid->p;
      if (p == 0 || p == 1) {
        hSbrFrameInfo->shortEnv = 0;
      } else {
        hSbrFrameInfo->shortEnv = p - 1;
      }

      for (k = 0; k < nEnv; k++) {
        hSbrFrameInfo->freqRes[k] = (FREQ_RES)v_f[k];
      }

      switch (p) {
        case 0:
          hSbrFrameInfo->bordersNoise[1] = hSbrFrameInfo->borders[1];
          break;
        case 1:
          hSbrFrameInfo->bordersNoise[1] = hSbrFrameInfo->borders[nEnv - 1];
          break;
        default:
          hSbrFrameInfo->bordersNoise[1] =
              hSbrFrameInfo->borders[hSbrFrameInfo->shortEnv];
          break;
      }
      break;

    case VARVAR:
      nEnv = hSbrGrid->bs_num_rel_0 + hSbrGrid->bs_num_rel_1 + 1;
      FDK_ASSERT(nEnv <= MAX_ENVELOPES_VARVAR); /* just to be sure */
      hSbrFrameInfo->nEnvelopes = nEnv;

      hSbrFrameInfo->borders[0] = border = hSbrGrid->bs_abs_bord_0;

      for (k = 0, i = 1; k < hSbrGrid->bs_num_rel_0; k++, i++) {
        border += hSbrGrid->bs_rel_bord_0[k];
        hSbrFrameInfo->borders[i] = border;
      }

      border = hSbrGrid->bs_abs_bord_1;
      hSbrFrameInfo->borders[nEnv] = border;

      for (k = 0, i = nEnv - 1; k < hSbrGrid->bs_num_rel_1; k++, i--) {
        border -= hSbrGrid->bs_rel_bord_1[k];
        hSbrFrameInfo->borders[i] = border;
      }

      p = hSbrGrid->p;
      if (p == 0) {
        hSbrFrameInfo->shortEnv = 0;
      } else {
        hSbrFrameInfo->shortEnv = nEnv + 1 - p;
      }

      for (k = 0; k < nEnv; k++) {
        hSbrFrameInfo->freqRes[k] = (FREQ_RES)hSbrGrid->v_fLR[k];
      }

      if (nEnv == 1) {
        hSbrFrameInfo->nNoiseEnvelopes = 1;
        hSbrFrameInfo->bordersNoise[0] = hSbrGrid->bs_abs_bord_0;
        hSbrFrameInfo->bordersNoise[1] = hSbrGrid->bs_abs_bord_1;
      } else {
        hSbrFrameInfo->nNoiseEnvelopes = 2;
        hSbrFrameInfo->bordersNoise[0] = hSbrGrid->bs_abs_bord_0;

        if (p == 0 || p == 1) {
          hSbrFrameInfo->bordersNoise[1] = hSbrFrameInfo->borders[nEnv - 1];
        } else {
          hSbrFrameInfo->bordersNoise[1] =
              hSbrFrameInfo->borders[hSbrFrameInfo->shortEnv];
        }
        hSbrFrameInfo->bordersNoise[2] = hSbrGrid->bs_abs_bord_1;
      }
      break;

    default:
      /* do nothing */
      break;
  }

  if (frameClass == VARFIX || frameClass == FIXVAR) {
    hSbrFrameInfo->bordersNoise[0] = hSbrFrameInfo->borders[0];
    if (nEnv == 1) {
      hSbrFrameInfo->bordersNoise[1] = hSbrFrameInfo->borders[nEnv];
    } else {
      hSbrFrameInfo->bordersNoise[2] = hSbrFrameInfo->borders[nEnv];
    }
  }
}

Coverage Report

Created: 2025-10-28 06:42