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

                       (C) copyright Fraunhofer-IIS (2004)
                               All Rights Reserved

    Please be advised that this software and/or program delivery is
    Confidential Information of Fraunhofer and subject to and covered by the

    Fraunhofer IIS Software Evaluation Agreement
    between Google Inc. and  Fraunhofer
    effective and in full force since March 1, 2012.

    You may use this software and/or program only under the terms and
    conditions described in the above mentioned Fraunhofer IIS Software
    Evaluation Agreement. Any other and/or further use requires a separate agreement.


   This software and/or program is protected by copyright law and international
   treaties. Any reproduction or distribution of this software and/or program,
   or any portion of it, may result in severe civil and criminal penalties, and
   will be prosecuted to the maximum extent possible under law.

 $Id$

*******************************************************************************/
#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,
                                  INT 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
                               );


/*!
  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,
                    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;
  INT freq_res_fixfix = hSbrEnvFrame->freq_res_fixfix;

  if (ldGrid) {
    /* in case there was a transient at the very end of the previous frame, start with a transient envelope */
    if(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
    ---------------------------------------------------------------------------*/
    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
                           );

      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,
                        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
                               )
{
  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];
    hSbrFrameInfo->freqRes[i] = freqResTable[k];
    //hSbrFrameInfo->freqRes[i] = (k < tuning.minEnvSize4highRes) ? FREQ_RES_LOW : FREQ_RES_HIGH;
    hSbrGrid->v_f[i] = freqResTable[k];
  }

  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,
                          INT freq_res_fixfix
                          ,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 = freq_res_fixfix;

  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->v_tuningSegm[0] = 0;
      hSbrEnvFrame->v_tuningSegm[1] = 2;
      hSbrEnvFrame->v_tuningSegm[2] = 3;
      */
      /*break;*/
  } 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:  deleteFrameInfoGenerator
 *******************************************************************************

 Description:

 Arguments:   hSbrEnvFrame  - HANDLE_SBR_ENVELOPE_FRAME

 Return:      none

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


/*******************************************************************************
 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;
      length_v_freq = 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:     2002/02/05 Andreas Schneider, CT
 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: Calculates frame_info struct from control signal.

 Arguments:   hSbrGrid - source
              hSbrFrameInfo - destination

 Return:      void; hSbrFrameInfo contains the updated FRAME_INFO struct

*******************************************************************************/
static void
ctrlSignal2FrameInfo (HANDLE_SBR_GRID hSbrGrid,
                      HANDLE_SBR_FRAME_INFO hSbrFrameInfo,
                      INT freq_res_fixfix)
{
  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);

    /* At this point all frequency resolutions are set to FREQ_RES_HIGH, so
     * only if freq_res_fixfix is set to FREQ_RES_LOW, they all have to be
     * changed.
     * snd */
    if (freq_res_fixfix == FREQ_RES_LOW) {
      for (i = 0; i < hSbrFrameInfo->nEnvelopes; i++) {
        hSbrFrameInfo->freqRes[i] = FREQ_RES_LOW;
      }
    }
    /* ELD: store current frequency resolution */
    hSbrGrid->v_f[0] = hSbrFrameInfo->freqRes[0];
    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];
    }
  }
}