/*
 *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

/*
 * encode.c
 *
 * This file contains definition of funtions for encoding.
 * Decoding of upper-band, including 8-12 kHz, when the bandwidth is
 * 0-12 kHz, and 8-16 kHz, when the bandwidth is 0-16 kHz.
 *
 */

#include <stdlib.h>
#include <string.h>

#include "structs.h"
#include "codec.h"
#include "pitch_estimator.h"
#include "entropy_coding.h"
#include "arith_routines.h"
#include "pitch_gain_tables.h"
#include "pitch_lag_tables.h"
#include "spectrum_ar_model_tables.h"
#include "lpc_tables.h"
#include "lpc_analysis.h"
#include "bandwidth_estimator.h"
#include "lpc_shape_swb12_tables.h"
#include "lpc_shape_swb16_tables.h"
#include "lpc_gain_swb_tables.h"


#define UB_LOOKAHEAD 24

/*
  Rate allocation tables of lower and upper-band bottleneck for
  12kHz & 16kHz bandwidth.

  12 kHz bandwidth
  -----------------
  The overall bottleneck of the coder is between 38 kbps and 45 kbps. We have
  considered 7 enteries, uniformly distributed in this interval, i.e. 38,
  39.17, 40.33, 41.5, 42.67, 43.83 and 45. For every entery, the lower-band
  and the upper-band bottlenecks are specified in
  'kLowerBandBitRate12' and 'kUpperBandBitRate12'
  tables, respectively. E.g. the overall rate of 41.5 kbps corresponts to a
  bottleneck of 31 kbps for lower-band and 27 kbps for upper-band. Given an
  overall bottleneck of the codec, we use linear interpolation to get
  lower-band and upper-band bottlenecks.

  16 kHz bandwidth
  -----------------
  The overall bottleneck of the coder is between 50 kbps and 56 kbps. We have
  considered 7 enteries, uniformly distributed in this interval, i.e. 50, 51.2,
  52.4, 53.6, 54.8 and 56. For every entery, the lower-band and the upper-band
  bottlenecks are specified in 'kLowerBandBitRate16' and
  'kUpperBandBitRate16' tables, respectively. E.g. the overall rate
  of 53.6 kbps corresponts to a bottleneck of 32 kbps for lower-band and 30
  kbps for upper-band. Given an overall bottleneck of the codec, we use linear
  interpolation to get lower-band and upper-band bottlenecks.

*/

//     38  39.17  40.33   41.5  42.67  43.83     45
static const WebRtc_Word16 kLowerBandBitRate12[7] = {
  29000, 30000, 30000, 31000, 31000, 32000, 32000};
static const WebRtc_Word16 kUpperBandBitRate12[7] = {
  25000, 25000, 27000, 27000, 29000, 29000, 32000};

//    50     51.2  52.4   53.6   54.8    56
static const WebRtc_Word16 kLowerBandBitRate16[6] = {
  31000, 31000, 32000, 32000, 32000, 32000};
static const WebRtc_Word16 kUpperBandBitRate16[6] = {
  28000, 29000, 29000, 30000, 31000, 32000};

/******************************************************************************
 * WebRtcIsac_RateAllocation()
 * Internal function to perform a rate-allocation for upper and lower-band,
 * given a total rate.
 *
 * Input:
 *   - inRateBitPerSec           : a total bottleneck in bits/sec.
 *
 * Output:
 *   - rateLBBitPerSec           : a bottleneck allocated to the lower-band
 *                                 in bits/sec.
 *   - rateUBBitPerSec           : a bottleneck allocated to the upper-band
 *                                 in bits/sec.
 *
 * Return value                  : 0 if rate allocation has been successful.
 *                                -1 if failed to allocate rates.
 */

WebRtc_Word16
WebRtcIsac_RateAllocation(
    WebRtc_Word32         inRateBitPerSec,
    double*             rateLBBitPerSec,
    double*             rateUBBitPerSec,
    enum ISACBandwidth* bandwidthKHz)
{
  WebRtc_Word16 idx;
  double idxD;
  double idxErr;
  if(inRateBitPerSec < 38000)
  {
    // If the given overall bottleneck is less than 38000 then
    // then codec has to operate in wideband mode, i.e. 8 kHz
    // bandwidth.
    *rateLBBitPerSec = (WebRtc_Word16)((inRateBitPerSec > 32000)?
                                       32000:inRateBitPerSec);
    *rateUBBitPerSec = 0;
    *bandwidthKHz = isac8kHz;
  }
  else if((inRateBitPerSec >= 38000) && (inRateBitPerSec < 50000))
  {
    // At a bottleneck between 38 and 50 kbps the codec is operating
    // at 12 kHz bandwidth. Using xxxBandBitRate12[] to calculates
    // upper/lower bottleneck

    // find the bottlenecks by linear interpolation
    // step is (45000 - 38000)/6.0 we use the inverse of it.
    const double stepSizeInv = 8.5714286e-4;
    idxD = (inRateBitPerSec - 38000) * stepSizeInv;
    idx = (idxD >= 6)? 6:((WebRtc_Word16)idxD);
    idxErr = idxD - idx;
    *rateLBBitPerSec = kLowerBandBitRate12[idx];
    *rateUBBitPerSec = kUpperBandBitRate12[idx];

    if(idx < 6)
    {
      *rateLBBitPerSec += (WebRtc_Word16)(idxErr *
                                          (kLowerBandBitRate12[idx + 1] -
                                           kLowerBandBitRate12[idx]));
      *rateUBBitPerSec += (WebRtc_Word16)(idxErr *
                                          (kUpperBandBitRate12[idx + 1] -
                                           kUpperBandBitRate12[idx]));
    }

    *bandwidthKHz = isac12kHz;
  }
  else if((inRateBitPerSec >= 50000) && (inRateBitPerSec <= 56000))
  {
    // A bottleneck between 50 and 56 kbps corresponds to bandwidth
    // of 16 kHz. Using xxxBandBitRate16[] to calculates
    // upper/lower bottleneck

    // find the bottlenecks by linear interpolation
    // step is (56000 - 50000)/5 we use the inverse of it
    const double stepSizeInv = 8.3333333e-4;
    idxD = (inRateBitPerSec - 50000) * stepSizeInv;
    idx = (idxD >= 5)? 5:((WebRtc_Word16)idxD);
    idxErr = idxD - idx;
    *rateLBBitPerSec = kLowerBandBitRate16[idx];
    *rateUBBitPerSec  = kUpperBandBitRate16[idx];

    if(idx < 5)
    {
      *rateLBBitPerSec += (WebRtc_Word16)(idxErr *
                                          (kLowerBandBitRate16[idx + 1] -
                                           kLowerBandBitRate16[idx]));

      *rateUBBitPerSec += (WebRtc_Word16)(idxErr *
                                          (kUpperBandBitRate16[idx + 1] -
                                           kUpperBandBitRate16[idx]));
    }

    *bandwidthKHz = isac16kHz;
  }
  else
  {
    // Out-of-range botlteneck value.
    return -1;
  }

  // limit the values.
  *rateLBBitPerSec = (*rateLBBitPerSec > 32000)? 32000:*rateLBBitPerSec;
  *rateUBBitPerSec = (*rateUBBitPerSec > 32000)? 32000:*rateUBBitPerSec;

  return 0;
}



int
WebRtcIsac_EncodeLb(
    float*           in,
    ISACLBEncStruct* ISACencLB_obj,
    WebRtc_Word16      codingMode,
    WebRtc_Word16      bottleneckIndex)
{
  int stream_length = 0;
  int err;
  int k;
  int iterCntr;

  double lofilt_coef[(ORDERLO+1)*SUBFRAMES];
  double hifilt_coef[(ORDERHI+1)*SUBFRAMES];
  float LP[FRAMESAMPLES_HALF];
  float HP[FRAMESAMPLES_HALF];

  double LP_lookahead[FRAMESAMPLES_HALF];
  double HP_lookahead[FRAMESAMPLES_HALF];
  double LP_lookahead_pf[FRAMESAMPLES_HALF + QLOOKAHEAD];
  double LPw[FRAMESAMPLES_HALF];

  double HPw[FRAMESAMPLES_HALF];
  double LPw_pf[FRAMESAMPLES_HALF];
  WebRtc_Word16 fre[FRAMESAMPLES_HALF];   /* Q7 */
  WebRtc_Word16 fim[FRAMESAMPLES_HALF];   /* Q7 */

  double PitchLags[4];
  double PitchGains[4];
  WebRtc_Word16 PitchGains_Q12[4];
  WebRtc_Word16 AvgPitchGain_Q12;

  int frame_mode; /* 0 for 30ms, 1 for 60ms */
  int processed_samples, status = 0;

  double bits_gains;
  int bmodel;

  transcode_obj transcodingParam;
  double bytesLeftSpecCoding;
  WebRtc_UWord16 payloadLimitBytes;

  /* copy new frame length and bottle neck rate only for the first
     10 ms data */
  if (ISACencLB_obj->buffer_index == 0) {
    /* set the framelength for the next packet */
    ISACencLB_obj->current_framesamples = ISACencLB_obj->new_framelength;
  }
  /* frame_mode is 0 (30 ms) or 1 (60 ms)  */
  frame_mode = ISACencLB_obj->current_framesamples/MAX_FRAMESAMPLES;
  /* processed_samples: 480 (30, 60 ms) */
  processed_samples = ISACencLB_obj->current_framesamples/(frame_mode+1);

  /* buffer speech samples (by 10ms packet) until the framelength */
  /* is reached (30 or 60 ms)                                     */
  /****************************************************************/

  /* fill the buffer with 10ms input data */
  for (k = 0; k < FRAMESAMPLES_10ms; k++) {
    ISACencLB_obj->data_buffer_float[k + ISACencLB_obj->buffer_index] =
        in[k];
  }

  /* if buffersize is not equal to current framesize then increase index
     and return. We do no encoding untill we have enough audio.  */
  if (ISACencLB_obj->buffer_index + FRAMESAMPLES_10ms != processed_samples) {
    ISACencLB_obj->buffer_index += FRAMESAMPLES_10ms;
    return 0;
  }
  /* if buffer reached the right size, reset index and continue with
     encoding the frame */
  ISACencLB_obj->buffer_index = 0;

  /* end of buffer function */
  /**************************/

  /* encoding */
  /************/

  if (frame_mode == 0 || ISACencLB_obj->frame_nb == 0 ) {
    // This is to avoid Linux warnings until we change 'int' to 'Word32'
    // at all places.
    int intVar;
    /* reset bitstream */
    ISACencLB_obj->bitstr_obj.W_upper = 0xFFFFFFFF;
    ISACencLB_obj->bitstr_obj.streamval = 0;
    ISACencLB_obj->bitstr_obj.stream_index = 0;

    if((codingMode == 0) && (frame_mode == 0) &&
       (ISACencLB_obj->enforceFrameSize == 0)) {
      ISACencLB_obj->new_framelength =
          WebRtcIsac_GetNewFrameLength(ISACencLB_obj->bottleneck,
                                       ISACencLB_obj->current_framesamples);
    }

    ISACencLB_obj->s2nr = WebRtcIsac_GetSnr(
        ISACencLB_obj->bottleneck, ISACencLB_obj->current_framesamples);

    /* encode frame length */
    status = WebRtcIsac_EncodeFrameLen(
        ISACencLB_obj->current_framesamples, &ISACencLB_obj->bitstr_obj);
    if (status < 0) {
      /* Wrong frame size */
      return status;
    }
    /* Save framelength for multiple packets memory */
    ISACencLB_obj->SaveEnc_obj.framelength =
        ISACencLB_obj->current_framesamples;

    /* To be used for Redundant Coding */
    ISACencLB_obj->lastBWIdx = bottleneckIndex;
    intVar = (int)bottleneckIndex;
    WebRtcIsac_EncodeReceiveBw(&intVar, &ISACencLB_obj->bitstr_obj);
  }

  /* split signal in two bands */
  WebRtcIsac_SplitAndFilterFloat(ISACencLB_obj->data_buffer_float, LP, HP,
                                 LP_lookahead, HP_lookahead,    &ISACencLB_obj->prefiltbankstr_obj );

  /* estimate pitch parameters and pitch-filter lookahead signal */
  WebRtcIsac_PitchAnalysis(LP_lookahead, LP_lookahead_pf,
                           &ISACencLB_obj->pitchanalysisstr_obj, PitchLags, PitchGains);

  /* encode in FIX Q12 */

  /* convert PitchGain to Fixed point */
  for (k=0;k<PITCH_SUBFRAMES;k++) {
    PitchGains_Q12[k] = (WebRtc_Word16)(PitchGains[k] * 4096.0);
  }

  /* Set where to store data in multiple packets memory */
  if (frame_mode == 0 || ISACencLB_obj->frame_nb == 0)
  {
    ISACencLB_obj->SaveEnc_obj.startIdx = 0;
  } else {
    ISACencLB_obj->SaveEnc_obj.startIdx = 1;
  }

  /* quantize & encode pitch parameters */
  WebRtcIsac_EncodePitchGain(PitchGains_Q12, &ISACencLB_obj->bitstr_obj,
                             &ISACencLB_obj->SaveEnc_obj);
  WebRtcIsac_EncodePitchLag(PitchLags, PitchGains_Q12,
                            &ISACencLB_obj->bitstr_obj, &ISACencLB_obj->SaveEnc_obj);

  AvgPitchGain_Q12 = (PitchGains_Q12[0] + PitchGains_Q12[1] +
                      PitchGains_Q12[2] + PitchGains_Q12[3])>>2;

  /* find coefficients for perceptual pre-filters */
  WebRtcIsac_GetLpcCoefLb(LP_lookahead_pf, HP_lookahead,
                          &ISACencLB_obj->maskfiltstr_obj, ISACencLB_obj->s2nr,
                          PitchGains_Q12, lofilt_coef, hifilt_coef);

  /* code LPC model and shape - gains not quantized yet */
  WebRtcIsac_EncodeLpcLb(lofilt_coef, hifilt_coef,  &bmodel, &bits_gains,
                         &ISACencLB_obj->bitstr_obj, &ISACencLB_obj->SaveEnc_obj);

  /* convert PitchGains back to FLOAT for pitchfilter_pre */
  for (k = 0; k < 4; k++) {
    PitchGains[k] = ((float)PitchGains_Q12[k])/4096;
  }

  /* Store the state of arithmetic coder before coding LPC gains */
  transcodingParam.W_upper      = ISACencLB_obj->bitstr_obj.W_upper;
  transcodingParam.stream_index = ISACencLB_obj->bitstr_obj.stream_index;
  transcodingParam.streamval    = ISACencLB_obj->bitstr_obj.streamval;
  transcodingParam.stream[0]    = ISACencLB_obj->bitstr_obj.stream[
      ISACencLB_obj->bitstr_obj.stream_index - 2];
  transcodingParam.stream[1]    = ISACencLB_obj->bitstr_obj.stream[
      ISACencLB_obj->bitstr_obj.stream_index - 1];
  transcodingParam.stream[2]    = ISACencLB_obj->bitstr_obj.stream[
      ISACencLB_obj->bitstr_obj.stream_index];

  /* Store LPC Gains before encoding them */
  for(k = 0; k < SUBFRAMES; k++) {
    transcodingParam.loFiltGain[k] = lofilt_coef[(LPC_LOBAND_ORDER+1)*k];
    transcodingParam.hiFiltGain[k] = hifilt_coef[(LPC_HIBAND_ORDER+1)*k];
  }

  /* Code gains */
  WebRtcIsac_EncodeLpcGainLb(lofilt_coef, hifilt_coef,  bmodel,
                             &ISACencLB_obj->bitstr_obj, &ISACencLB_obj->SaveEnc_obj);

  /* Get the correct value for the payload limit and calculate the
     number of bytes left for coding the spectrum.*/
  if((frame_mode == 1) && (ISACencLB_obj->frame_nb == 0)) {
    /* It is a 60ms and we are in the first 30ms then the limit at
       this point should be half of the assigned value */
    payloadLimitBytes = ISACencLB_obj->payloadLimitBytes60 >> 1;
  }
  else if (frame_mode == 0) {
    /* It is a 30ms frame */
    /* Subract 3 because termination process may add 3 bytes */
    payloadLimitBytes = ISACencLB_obj->payloadLimitBytes30 - 3;
  } else {
    /* This is the second half of a 60ms frame. */
    /* Subract 3 because termination process may add 3 bytes */
    payloadLimitBytes = ISACencLB_obj->payloadLimitBytes60 - 3;
  }
  bytesLeftSpecCoding = payloadLimitBytes - transcodingParam.stream_index;

  /* perceptual pre-filtering (using normalized lattice filter) */
  /* low-band filtering */
  WebRtcIsac_NormLatticeFilterMa(ORDERLO,
                                  ISACencLB_obj->maskfiltstr_obj.PreStateLoF,
                                  ISACencLB_obj->maskfiltstr_obj.PreStateLoG, LP, lofilt_coef, LPw);
  /* high-band filtering */
  WebRtcIsac_NormLatticeFilterMa(ORDERHI,
                                  ISACencLB_obj->maskfiltstr_obj.PreStateHiF,
                                  ISACencLB_obj->maskfiltstr_obj.PreStateHiG, HP, hifilt_coef, HPw);


  /* pitch filter */
  WebRtcIsac_PitchfilterPre(LPw, LPw_pf, &ISACencLB_obj->pitchfiltstr_obj,
                             PitchLags, PitchGains);

  /* transform */
  WebRtcIsac_Time2Spec(LPw_pf, HPw, fre, fim, &ISACencLB_obj->fftstr_obj);


  /* Save data for multiple packets memory */
  for (k = 0; k < FRAMESAMPLES_HALF; k++) {
    ISACencLB_obj->SaveEnc_obj.fre[k +
                                   ISACencLB_obj->SaveEnc_obj.startIdx*FRAMESAMPLES_HALF] = fre[k];
    ISACencLB_obj->SaveEnc_obj.fim[k +
                                   ISACencLB_obj->SaveEnc_obj.startIdx*FRAMESAMPLES_HALF] = fim[k];
  }
  ISACencLB_obj->SaveEnc_obj.AvgPitchGain[
      ISACencLB_obj->SaveEnc_obj.startIdx] = AvgPitchGain_Q12;

  /* quantization and lossless coding */
  err = WebRtcIsac_EncodeSpecLb(fre, fim, &ISACencLB_obj->bitstr_obj,
                                AvgPitchGain_Q12);
  if ((err < 0) && (err != -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
    /* There has been an error but it was not too large payload
       (we can cure too large payload) */
    if (frame_mode == 1 && ISACencLB_obj->frame_nb == 1) {
      /* If this is the second 30ms of a 60ms frame reset
         this such that in the next call encoder starts fresh. */
      ISACencLB_obj->frame_nb = 0;
    }
    return err;
  }
  iterCntr = 0;
  while((ISACencLB_obj->bitstr_obj.stream_index > payloadLimitBytes) ||
        (err == -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
    double bytesSpecCoderUsed;
    double transcodeScale;

    if(iterCntr >= MAX_PAYLOAD_LIMIT_ITERATION) {
      /* We were not able to limit the payload size */
      if((frame_mode == 1) && (ISACencLB_obj->frame_nb == 0)) {
        /* This was the first 30ms of a 60ms frame. Although
           the payload is larger than it should be but we let
           the second 30ms be encoded. Maybe together we
           won't exceed the limit. */
        ISACencLB_obj->frame_nb = 1;
        return 0;
      } else if((frame_mode == 1) && (ISACencLB_obj->frame_nb == 1)) {
        ISACencLB_obj->frame_nb = 0;
      }

      if(err != -ISAC_DISALLOWED_BITSTREAM_LENGTH) {
        return -ISAC_PAYLOAD_LARGER_THAN_LIMIT;
      } else {
        return status;
      }
    }

    if(err == -ISAC_DISALLOWED_BITSTREAM_LENGTH) {
      bytesSpecCoderUsed = STREAM_SIZE_MAX;
      // being coservative
      transcodeScale = bytesLeftSpecCoding / bytesSpecCoderUsed * 0.5;
    } else {
      bytesSpecCoderUsed = ISACencLB_obj->bitstr_obj.stream_index -
          transcodingParam.stream_index;
      transcodeScale = bytesLeftSpecCoding / bytesSpecCoderUsed;
    }

    /* To be safe, we reduce the scale depending on
       the number of iterations. */
    transcodeScale *= (1.0 - (0.9 * (double)iterCntr /
                              (double)MAX_PAYLOAD_LIMIT_ITERATION));

    /* Scale the LPC Gains */
    for (k = 0; k < SUBFRAMES; k++) {
      lofilt_coef[(LPC_LOBAND_ORDER+1) * k] =
          transcodingParam.loFiltGain[k] * transcodeScale;
      hifilt_coef[(LPC_HIBAND_ORDER+1) * k] =
          transcodingParam.hiFiltGain[k] * transcodeScale;
      transcodingParam.loFiltGain[k] =
          lofilt_coef[(LPC_LOBAND_ORDER+1) * k];
      transcodingParam.hiFiltGain[k] =
          hifilt_coef[(LPC_HIBAND_ORDER+1) * k];
    }

    /* Scale DFT coefficients */
    for (k = 0; k < FRAMESAMPLES_HALF; k++) {
      fre[k] = (WebRtc_Word16)(fre[k] * transcodeScale);
      fim[k] = (WebRtc_Word16)(fim[k] * transcodeScale);
    }

    /* Save data for multiple packets memory */
    for (k = 0; k < FRAMESAMPLES_HALF; k++) {
      ISACencLB_obj->SaveEnc_obj.fre[k +
                                     ISACencLB_obj->SaveEnc_obj.startIdx * FRAMESAMPLES_HALF] =
          fre[k];
      ISACencLB_obj->SaveEnc_obj.fim[k +
                                     ISACencLB_obj->SaveEnc_obj.startIdx * FRAMESAMPLES_HALF] =
          fim[k];
    }

    /* Re-store the state of arithmetic coder before coding LPC gains */
    ISACencLB_obj->bitstr_obj.W_upper = transcodingParam.W_upper;
    ISACencLB_obj->bitstr_obj.stream_index = transcodingParam.stream_index;
    ISACencLB_obj->bitstr_obj.streamval = transcodingParam.streamval;
    ISACencLB_obj->bitstr_obj.stream[transcodingParam.stream_index - 2] =
        transcodingParam.stream[0];
    ISACencLB_obj->bitstr_obj.stream[transcodingParam.stream_index - 1] =
        transcodingParam.stream[1];
    ISACencLB_obj->bitstr_obj.stream[transcodingParam.stream_index] =
        transcodingParam.stream[2];

    /* Code gains */
    WebRtcIsac_EncodeLpcGainLb(lofilt_coef, hifilt_coef,  bmodel,
                               &ISACencLB_obj->bitstr_obj, &ISACencLB_obj->SaveEnc_obj);

    /* Update the number of bytes left for encoding the spectrum */
    bytesLeftSpecCoding = payloadLimitBytes -
        transcodingParam.stream_index;

    /* Encode the spectrum */
    err = WebRtcIsac_EncodeSpecLb(fre, fim, &ISACencLB_obj->bitstr_obj,
                                  AvgPitchGain_Q12);
    if((err < 0) && (err != -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
      /* There has been an error but it was not too large
         payload (we can cure too large payload) */
      if (frame_mode == 1 && ISACencLB_obj->frame_nb == 1) {
        /* If this is the second 30ms of a 60ms frame reset
           this such that in the next call encoder starts fresh. */
        ISACencLB_obj->frame_nb = 0;
      }
      return err;
    }
    iterCntr++;
  }

  /* i.e. 60 ms framesize and just processed the first 30ms, */
  /* go back to main function to buffer the other 30ms speech frame */
  if (frame_mode == 1)
  {
    if(ISACencLB_obj->frame_nb == 0)
    {
      ISACencLB_obj->frame_nb = 1;
      return 0;
    }
    else if(ISACencLB_obj->frame_nb == 1)
    {
      ISACencLB_obj->frame_nb = 0;
      /* also update the framelength for next packet,
         in Adaptive mode only */
      if (codingMode == 0 && (ISACencLB_obj->enforceFrameSize == 0))
      {
        ISACencLB_obj->new_framelength =
            WebRtcIsac_GetNewFrameLength(ISACencLB_obj->bottleneck,
                                         ISACencLB_obj->current_framesamples);
      }
    }
  }
  else
  {
    ISACencLB_obj->frame_nb = 0;
  }

  /* complete arithmetic coding */
  stream_length = WebRtcIsac_EncTerminate(&ISACencLB_obj->bitstr_obj);

  return stream_length;
}

int
WebRtcIsac_EncodeUb16(
    float*           in,
    ISACUBEncStruct* ISACencUB_obj,
    WebRtc_Word32      jitterInfo)
{
  int err;
  int k;

  double lpcVecs[UB_LPC_ORDER * UB16_LPC_VEC_PER_FRAME];
  double percepFilterParams[(1 + UB_LPC_ORDER) * (SUBFRAMES<<1) +
                            (1 + UB_LPC_ORDER)];

  double LP_lookahead[FRAMESAMPLES];
  WebRtc_Word16 fre[FRAMESAMPLES_HALF];   /* Q7 */
  WebRtc_Word16 fim[FRAMESAMPLES_HALF];   /* Q7 */

  int status = 0;

  double varscale[2];
  double corr[SUBFRAMES<<1][UB_LPC_ORDER + 1];
  double lpcGains[SUBFRAMES<<1];
  transcode_obj transcodingParam;
  double bytesLeftSpecCoding;
  WebRtc_UWord16 payloadLimitBytes;
  WebRtc_UWord16 iterCntr;
  double s2nr;

  /* buffer speech samples (by 10ms packet) until the framelength is   */
  /* reached (30 or 60 ms)                                             */
  /*********************************************************************/

  /* fill the buffer with 10ms input data */
  for (k = 0; k < FRAMESAMPLES_10ms; k++) {
    ISACencUB_obj->data_buffer_float[k + ISACencUB_obj->buffer_index] =
        in[k];
  }

  /* if buffersize is not equal to current framesize, and end of file is
     not reached yet, we don't do encoding unless we have the whole frame */
  if (ISACencUB_obj->buffer_index + FRAMESAMPLES_10ms < FRAMESAMPLES) {
    ISACencUB_obj->buffer_index += FRAMESAMPLES_10ms;
    return 0;
  }

  /* end of buffer function */
  /**************************/

  /* encoding */
  /************/

  /* reset bitstream */
  ISACencUB_obj->bitstr_obj.W_upper = 0xFFFFFFFF;
  ISACencUB_obj->bitstr_obj.streamval = 0;
  ISACencUB_obj->bitstr_obj.stream_index = 0;

  /* bandwidth estimation and coding */
  /* To be used for Redundant Coding */
  WebRtcIsac_EncodeJitterInfo(jitterInfo, &ISACencUB_obj->bitstr_obj);

  status = WebRtcIsac_EncodeBandwidth(isac16kHz,
                                      &ISACencUB_obj->bitstr_obj);
  if (status < 0) {
    return status;
  }

  s2nr = WebRtcIsac_GetSnr(ISACencUB_obj->bottleneck,
                                 FRAMESAMPLES);

  memcpy(lpcVecs, ISACencUB_obj->lastLPCVec, UB_LPC_ORDER * sizeof(double));

  for (k = 0; k < FRAMESAMPLES; k++) {
    LP_lookahead[k] = ISACencUB_obj->data_buffer_float[UB_LOOKAHEAD + k];
  }

  /* find coefficients for perceptual pre-filters */
  WebRtcIsac_GetLpcCoefUb(LP_lookahead, &ISACencUB_obj->maskfiltstr_obj,
                            &lpcVecs[UB_LPC_ORDER], corr, varscale, isac16kHz);

  memcpy(ISACencUB_obj->lastLPCVec,
         &lpcVecs[(UB16_LPC_VEC_PER_FRAME - 1) * (UB_LPC_ORDER)],
         sizeof(double) * UB_LPC_ORDER);

  /* code LPC model and shape - gains not quantized yet */
  WebRtcIsac_EncodeLpcUB(lpcVecs, &ISACencUB_obj->bitstr_obj,
                           percepFilterParams, isac16kHz, &ISACencUB_obj->SaveEnc_obj);


  // the first set of lpc parameters are from the last sub-frame of
  // the previous frame. so we don't care about them
  WebRtcIsac_GetLpcGain(s2nr, &percepFilterParams[UB_LPC_ORDER + 1],
                       (SUBFRAMES<<1), lpcGains, corr, varscale);

  /* Store the state of arithmetic coder before coding LPC gains */
  transcodingParam.stream_index = ISACencUB_obj->bitstr_obj.stream_index;
  transcodingParam.W_upper      = ISACencUB_obj->bitstr_obj.W_upper;
  transcodingParam.streamval    = ISACencUB_obj->bitstr_obj.streamval;
  transcodingParam.stream[0]    = ISACencUB_obj->bitstr_obj.stream[
      ISACencUB_obj->bitstr_obj.stream_index - 2];
  transcodingParam.stream[1]    = ISACencUB_obj->bitstr_obj.stream[
      ISACencUB_obj->bitstr_obj.stream_index - 1];
  transcodingParam.stream[2]    = ISACencUB_obj->bitstr_obj.stream[
      ISACencUB_obj->bitstr_obj.stream_index];

  /* Store LPC Gains before encoding them */
  for(k = 0; k < SUBFRAMES; k++) {
    transcodingParam.loFiltGain[k] = lpcGains[k];
    transcodingParam.hiFiltGain[k] = lpcGains[SUBFRAMES + k];
  }

  // Store the gains for multiple encoding
  memcpy(ISACencUB_obj->SaveEnc_obj.lpcGain, lpcGains, (SUBFRAMES << 1) * sizeof(double));

  WebRtcIsac_EncodeLpcGainUb(lpcGains, &ISACencUB_obj->bitstr_obj,
                             ISACencUB_obj->SaveEnc_obj.lpcGainIndex);
  WebRtcIsac_EncodeLpcGainUb(&lpcGains[SUBFRAMES], &ISACencUB_obj->bitstr_obj,
                             &ISACencUB_obj->SaveEnc_obj.lpcGainIndex[SUBFRAMES]);

  /* Get the correct value for the payload limit and calculate the number of
     bytes left for coding the spectrum. It is a 30ms frame
     Subract 3 because termination process may add 3 bytes */
  payloadLimitBytes = ISACencUB_obj->maxPayloadSizeBytes -
      ISACencUB_obj->numBytesUsed - 3;
  bytesLeftSpecCoding = payloadLimitBytes -
      ISACencUB_obj->bitstr_obj.stream_index;

  for (k = 0; k < (SUBFRAMES<<1); k++) {
    percepFilterParams[k*(UB_LPC_ORDER + 1) + (UB_LPC_ORDER + 1)] =
        lpcGains[k];
  }

  /* perceptual pre-filtering (using normalized lattice filter) */
  /* first half-frame filtering */
  WebRtcIsac_NormLatticeFilterMa(UB_LPC_ORDER,
                                  ISACencUB_obj->maskfiltstr_obj.PreStateLoF,
                                  ISACencUB_obj->maskfiltstr_obj.PreStateLoG,
                                  &ISACencUB_obj->data_buffer_float[0],
                                  &percepFilterParams[UB_LPC_ORDER + 1],
                                  &LP_lookahead[0]);

  /* Second half-frame filtering */
  WebRtcIsac_NormLatticeFilterMa(UB_LPC_ORDER,
                                  ISACencUB_obj->maskfiltstr_obj.PreStateLoF,
                                  ISACencUB_obj->maskfiltstr_obj.PreStateLoG,
                                  &ISACencUB_obj->data_buffer_float[FRAMESAMPLES_HALF],
                                  &percepFilterParams[(UB_LPC_ORDER + 1) + SUBFRAMES *
                                                      (UB_LPC_ORDER + 1)], &LP_lookahead[FRAMESAMPLES_HALF]);

  WebRtcIsac_Time2Spec(&LP_lookahead[0], &LP_lookahead[FRAMESAMPLES_HALF],
                      fre, fim, &ISACencUB_obj->fftstr_obj);

  //Store FFT coefficients for multiple encoding
  memcpy(&ISACencUB_obj->SaveEnc_obj.realFFT, fre,
         FRAMESAMPLES_HALF * sizeof(WebRtc_Word16));

  memcpy(&ISACencUB_obj->SaveEnc_obj.imagFFT, fim,
         FRAMESAMPLES_HALF * sizeof(WebRtc_Word16));

  // Prepare the audio buffer for the next packet
  // move the last 3 ms to the beginning of the buffer
  memcpy(ISACencUB_obj->data_buffer_float,
         &ISACencUB_obj->data_buffer_float[FRAMESAMPLES],
         LB_TOTAL_DELAY_SAMPLES * sizeof(float));
  // start writing with 3 ms delay to compensate for the delay
  // of the lower-band.
  ISACencUB_obj->buffer_index = LB_TOTAL_DELAY_SAMPLES;

  // Save the bit-stream object at this point for FEC.
  memcpy(&ISACencUB_obj->SaveEnc_obj.bitStreamObj,
         &ISACencUB_obj->bitstr_obj, sizeof(Bitstr));

  /* quantization and lossless coding */
  err = WebRtcIsac_EncodeSpecUB16(fre, fim, &ISACencUB_obj->bitstr_obj);
  if ((err < 0) && (err != -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
    return err;
  }

  iterCntr = 0;
  while((ISACencUB_obj->bitstr_obj.stream_index > payloadLimitBytes) ||
        (err == -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
    double bytesSpecCoderUsed;
    double transcodeScale;

    if (iterCntr >= MAX_PAYLOAD_LIMIT_ITERATION) {
      /* We were not able to limit the payload size */
      return -ISAC_PAYLOAD_LARGER_THAN_LIMIT;
    }

    if (err == -ISAC_DISALLOWED_BITSTREAM_LENGTH) {
      bytesSpecCoderUsed = STREAM_SIZE_MAX;
      // being conservative
      transcodeScale = bytesLeftSpecCoding / bytesSpecCoderUsed * 0.5;
    } else {
      bytesSpecCoderUsed = ISACencUB_obj->bitstr_obj.stream_index -
          transcodingParam.stream_index;
      transcodeScale = bytesLeftSpecCoding / bytesSpecCoderUsed;
    }

    /* To be safe, we reduce the scale depending on the
       number of iterations. */
    transcodeScale *= (1.0 - (0.9 * (double)iterCntr/
                              (double)MAX_PAYLOAD_LIMIT_ITERATION));

    /* Scale the LPC Gains */
    for (k = 0; k < SUBFRAMES; k++) {
      transcodingParam.loFiltGain[k] *= transcodeScale;
      transcodingParam.hiFiltGain[k] *= transcodeScale;
    }

    /* Scale DFT coefficients */
    for (k = 0; k < FRAMESAMPLES_HALF; k++) {
      fre[k] = (WebRtc_Word16)(fre[k] * transcodeScale + 0.5);
      fim[k] = (WebRtc_Word16)(fim[k] * transcodeScale + 0.5);
    }

    //Store FFT coefficients for multiple encoding
    memcpy(&ISACencUB_obj->SaveEnc_obj.realFFT, fre,
           FRAMESAMPLES_HALF * sizeof(WebRtc_Word16));

    memcpy(&ISACencUB_obj->SaveEnc_obj.imagFFT, fim,
           FRAMESAMPLES_HALF * sizeof(WebRtc_Word16));


    /* Store the state of arithmetic coder before coding LPC gains */
    ISACencUB_obj->bitstr_obj.W_upper = transcodingParam.W_upper;

    ISACencUB_obj->bitstr_obj.stream_index = transcodingParam.stream_index;

    ISACencUB_obj->bitstr_obj.streamval = transcodingParam.streamval;

    ISACencUB_obj->bitstr_obj.stream[transcodingParam.stream_index - 2] =
        transcodingParam.stream[0];

    ISACencUB_obj->bitstr_obj.stream[transcodingParam.stream_index - 1] =
        transcodingParam.stream[1];

    ISACencUB_obj->bitstr_obj.stream[transcodingParam.stream_index] =
        transcodingParam.stream[2];

    // Store the gains for multiple encoding
    memcpy(ISACencUB_obj->SaveEnc_obj.lpcGain, lpcGains,
           (SUBFRAMES << 1) * sizeof(double));

    WebRtcIsac_EncodeLpcGainUb(transcodingParam.loFiltGain,
                               &ISACencUB_obj->bitstr_obj,
                               ISACencUB_obj->SaveEnc_obj.lpcGainIndex);
    WebRtcIsac_EncodeLpcGainUb(transcodingParam.hiFiltGain,
                               &ISACencUB_obj->bitstr_obj,
                               &ISACencUB_obj->SaveEnc_obj.lpcGainIndex[SUBFRAMES]);

    /* Update the number of bytes left for encoding the spectrum */
    bytesLeftSpecCoding = payloadLimitBytes -
        ISACencUB_obj->bitstr_obj.stream_index;

    // Save the bit-stream object at this point for FEC.
    memcpy(&ISACencUB_obj->SaveEnc_obj.bitStreamObj,
           &ISACencUB_obj->bitstr_obj, sizeof(Bitstr));

    /* Encode the spectrum */
    err = WebRtcIsac_EncodeSpecUB16(fre, fim, &ISACencUB_obj->bitstr_obj);
    if ((err < 0) && (err != -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
      /* There has been an error but it was not too large payload
         (we can cure too large payload) */
      return err;
    }
    iterCntr++;
  }

  /* complete arithmetic coding */
  return WebRtcIsac_EncTerminate(&ISACencUB_obj->bitstr_obj);
}


int
WebRtcIsac_EncodeUb12(
    float*           in,
    ISACUBEncStruct* ISACencUB_obj,
    WebRtc_Word32      jitterInfo)
{
  int err;
  int k;
  int iterCntr;

  double lpcVecs[UB_LPC_ORDER * UB_LPC_VEC_PER_FRAME];

  double percepFilterParams[(1 + UB_LPC_ORDER) * SUBFRAMES];
  float LP[FRAMESAMPLES_HALF];
  float HP[FRAMESAMPLES_HALF];

  double LP_lookahead[FRAMESAMPLES_HALF];
  double HP_lookahead[FRAMESAMPLES_HALF];
  double LPw[FRAMESAMPLES_HALF];

  double HPw[FRAMESAMPLES_HALF];
  WebRtc_Word16 fre[FRAMESAMPLES_HALF];   /* Q7 */
  WebRtc_Word16 fim[FRAMESAMPLES_HALF];   /* Q7 */

  int status = 0;

  double varscale[1];

  double corr[UB_LPC_GAIN_DIM][UB_LPC_ORDER + 1];
  double lpcGains[SUBFRAMES];
  transcode_obj transcodingParam;
  double bytesLeftSpecCoding;
  WebRtc_UWord16 payloadLimitBytes;
  double s2nr;

  /* buffer speech samples (by 10ms packet) until the framelength is  */
  /* reached (30 or 60 ms)                                            */
  /********************************************************************/

  /* fill the buffer with 10ms input data */
  for (k=0; k<FRAMESAMPLES_10ms; k++) {
    ISACencUB_obj->data_buffer_float[k + ISACencUB_obj->buffer_index] =
        in[k];
  }

  /* if buffer-size is not equal to current frame-size then increase the
     index and return. We do the encoding when we have enough audio.     */
  if (ISACencUB_obj->buffer_index + FRAMESAMPLES_10ms < FRAMESAMPLES) {
    ISACencUB_obj->buffer_index += FRAMESAMPLES_10ms;
    return 0;
  }
  /* if buffer reached the right size, reset index and continue
     with encoding the frame */
  ISACencUB_obj->buffer_index = 0;

  /* end of buffer function */
  /**************************/

  /* encoding */
  /************/

  /* reset bitstream */
  ISACencUB_obj->bitstr_obj.W_upper = 0xFFFFFFFF;
  ISACencUB_obj->bitstr_obj.streamval = 0;
  ISACencUB_obj->bitstr_obj.stream_index = 0;

  /* bandwidth estimation and coding */
  /* To be used for Redundant Coding */
  WebRtcIsac_EncodeJitterInfo(jitterInfo, &ISACencUB_obj->bitstr_obj);

  status = WebRtcIsac_EncodeBandwidth(isac12kHz,
                                      &ISACencUB_obj->bitstr_obj);
  if (status < 0) {
    return status;
  }


  s2nr = WebRtcIsac_GetSnr(ISACencUB_obj->bottleneck,
                                 FRAMESAMPLES);

  /* split signal in two bands */
  WebRtcIsac_SplitAndFilterFloat(ISACencUB_obj->data_buffer_float, HP, LP,
                                 HP_lookahead, LP_lookahead, &ISACencUB_obj->prefiltbankstr_obj);

  /* find coefficients for perceptual pre-filters */
  WebRtcIsac_GetLpcCoefUb(LP_lookahead, &ISACencUB_obj->maskfiltstr_obj,
                            lpcVecs, corr, varscale, isac12kHz);

  /* code LPC model and shape - gains not quantized yet */
  WebRtcIsac_EncodeLpcUB(lpcVecs, &ISACencUB_obj->bitstr_obj,
                           percepFilterParams, isac12kHz, &ISACencUB_obj->SaveEnc_obj);

  WebRtcIsac_GetLpcGain(s2nr, percepFilterParams, SUBFRAMES, lpcGains,
                       corr, varscale);

  /* Store the state of arithmetic coder before coding LPC gains */
  transcodingParam.W_upper = ISACencUB_obj->bitstr_obj.W_upper;

  transcodingParam.stream_index = ISACencUB_obj->bitstr_obj.stream_index;

  transcodingParam.streamval = ISACencUB_obj->bitstr_obj.streamval;

  transcodingParam.stream[0] = ISACencUB_obj->bitstr_obj.stream[
      ISACencUB_obj->bitstr_obj.stream_index - 2];

  transcodingParam.stream[1] = ISACencUB_obj->bitstr_obj.stream[
      ISACencUB_obj->bitstr_obj.stream_index - 1];

  transcodingParam.stream[2] = ISACencUB_obj->bitstr_obj.stream[
      ISACencUB_obj->bitstr_obj.stream_index];

  /* Store LPC Gains before encoding them */
  for(k = 0; k < SUBFRAMES; k++) {
    transcodingParam.loFiltGain[k] = lpcGains[k];
  }

  // Store the gains for multiple encoding
  memcpy(ISACencUB_obj->SaveEnc_obj.lpcGain, lpcGains, SUBFRAMES *
         sizeof(double));

  WebRtcIsac_EncodeLpcGainUb(lpcGains, &ISACencUB_obj->bitstr_obj,
                             ISACencUB_obj->SaveEnc_obj.lpcGainIndex);

  for(k = 0; k < SUBFRAMES; k++) {
    percepFilterParams[k*(UB_LPC_ORDER + 1)] = lpcGains[k];
  }

  /* perceptual pre-filtering (using normalized lattice filter) */
  /* low-band filtering */
  WebRtcIsac_NormLatticeFilterMa(UB_LPC_ORDER,
                                  ISACencUB_obj->maskfiltstr_obj.PreStateLoF,
                                  ISACencUB_obj->maskfiltstr_obj.PreStateLoG, LP, percepFilterParams,
                                  LPw);

  /* Get the correct value for the payload limit and calculate the number
     of bytes left for coding the spectrum. It is a 30ms frame Subract 3
     because termination process may add 3 bytes */
  payloadLimitBytes = ISACencUB_obj->maxPayloadSizeBytes -
      ISACencUB_obj->numBytesUsed - 3;
  bytesLeftSpecCoding = payloadLimitBytes -
      ISACencUB_obj->bitstr_obj.stream_index;

  memset(HPw, 0, sizeof(double) * FRAMESAMPLES_HALF);

  /* transform */
  WebRtcIsac_Time2Spec(LPw, HPw, fre, fim, &ISACencUB_obj->fftstr_obj);

  //Store real FFT coefficients for multiple encoding
  memcpy(&ISACencUB_obj->SaveEnc_obj.realFFT, fre,
         FRAMESAMPLES_HALF * sizeof(WebRtc_Word16));

  //Store imaginary FFT coefficients for multiple encoding
  memcpy(&ISACencUB_obj->SaveEnc_obj.imagFFT, fim,
         FRAMESAMPLES_HALF * sizeof(WebRtc_Word16));

  // Save the bit-stream object at this point for FEC.
  memcpy(&ISACencUB_obj->SaveEnc_obj.bitStreamObj,
         &ISACencUB_obj->bitstr_obj, sizeof(Bitstr));

  /* quantization and lossless coding */
  err = WebRtcIsac_EncodeSpecUB12(fre, fim, &ISACencUB_obj->bitstr_obj);
  if ((err < 0) && (err != -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
    /* There has been an error but it was not too large
       payload (we can cure too large payload) */
    return err;
  }
  iterCntr = 0;
  while((ISACencUB_obj->bitstr_obj.stream_index > payloadLimitBytes) ||
        (err == -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
    double bytesSpecCoderUsed;
    double transcodeScale;

    if (iterCntr >= MAX_PAYLOAD_LIMIT_ITERATION) {
      /* We were not able to limit the payload size */
      return -ISAC_PAYLOAD_LARGER_THAN_LIMIT;
    }

    if (err == -ISAC_DISALLOWED_BITSTREAM_LENGTH) {
      bytesSpecCoderUsed = STREAM_SIZE_MAX;
      // being coservative
      transcodeScale = bytesLeftSpecCoding / bytesSpecCoderUsed * 0.5;
    } else {
      bytesSpecCoderUsed = ISACencUB_obj->bitstr_obj.stream_index -
          transcodingParam.stream_index;
      transcodeScale = bytesLeftSpecCoding / bytesSpecCoderUsed;
    }

    /* To be safe, we reduce the scale depending on the
       number of iterations. */
    transcodeScale *= (1.0 - (0.9 * (double)iterCntr/
                              (double)MAX_PAYLOAD_LIMIT_ITERATION));

    /* Scale the LPC Gains */
    for (k = 0; k < SUBFRAMES; k++) {
      transcodingParam.loFiltGain[k] *= transcodeScale;
    }

    /* Scale DFT coefficients */
    for (k = 0; k < FRAMESAMPLES_HALF; k++) {
      fre[k] = (WebRtc_Word16)(fre[k] * transcodeScale + 0.5);
      fim[k] = (WebRtc_Word16)(fim[k] * transcodeScale + 0.5);
    }

    //Store real FFT coefficients for multiple encoding
    memcpy(&ISACencUB_obj->SaveEnc_obj.realFFT, fre,
           FRAMESAMPLES_HALF * sizeof(WebRtc_Word16));

    //Store imaginary FFT coefficients for multiple encoding
    memcpy(&ISACencUB_obj->SaveEnc_obj.imagFFT, fim,
           FRAMESAMPLES_HALF * sizeof(WebRtc_Word16));


    /* Re-store the state of arithmetic coder before coding LPC gains */
    ISACencUB_obj->bitstr_obj.W_upper = transcodingParam.W_upper;

    ISACencUB_obj->bitstr_obj.stream_index = transcodingParam.stream_index;

    ISACencUB_obj->bitstr_obj.streamval = transcodingParam.streamval;

    ISACencUB_obj->bitstr_obj.stream[transcodingParam.stream_index - 2] =
        transcodingParam.stream[0];

    ISACencUB_obj->bitstr_obj.stream[transcodingParam.stream_index - 1] =
        transcodingParam.stream[1];

    ISACencUB_obj->bitstr_obj.stream[transcodingParam.stream_index] =
        transcodingParam.stream[2];

    // Store the gains for multiple encoding
    memcpy(&ISACencUB_obj->SaveEnc_obj.lpcGain, lpcGains, SUBFRAMES *
           sizeof(double));

    // encode LPC gain and store quantization indices. HAving quantization
    // indices reduces transcoding complexity if 'scale factor' is 1.
    WebRtcIsac_EncodeLpcGainUb(transcodingParam.loFiltGain,
                               &ISACencUB_obj->bitstr_obj,
                               ISACencUB_obj->SaveEnc_obj.lpcGainIndex);

    // Save the bit-stream object at this point for FEC.
    memcpy(&ISACencUB_obj->SaveEnc_obj.bitStreamObj,
           &ISACencUB_obj->bitstr_obj, sizeof(Bitstr));

    /* Update the number of bytes left for encoding the spectrum */
    bytesLeftSpecCoding = payloadLimitBytes -
        ISACencUB_obj->bitstr_obj.stream_index;

    /* Encode the spectrum */
    err = WebRtcIsac_EncodeSpecUB12(fre, fim,
                                      &ISACencUB_obj->bitstr_obj);
    if ((err < 0) && (err != -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
      /* There has been an error but it was not too large payload
         (we can cure too large payload) */
      return err;
    }
    iterCntr++;
  }

  /* complete arithmetic coding */
  return WebRtcIsac_EncTerminate(&ISACencUB_obj->bitstr_obj);
}






/* This function is used to create a new bitstream with new BWE.
   The same data as previously encoded with the function WebRtcIsac_Encoder().
   The data needed is taken from the struct, where it was stored
   when calling the encoder. */

int WebRtcIsac_EncodeStoredDataLb(
    const ISAC_SaveEncData_t* ISACSavedEnc_obj,
    Bitstr*                   ISACBitStr_obj,
    int                       BWnumber,
    float                     scale)
{
  int ii;
  int status;
  int BWno = BWnumber;

  const WebRtc_UWord16 *WebRtcIsac_kQPitchGainCdf_ptr[1];
  const WebRtc_UWord16 **cdf;

  double tmpLPCcoeffs_lo[(ORDERLO+1)*SUBFRAMES*2];
  double tmpLPCcoeffs_hi[(ORDERHI+1)*SUBFRAMES*2];
  int tmpLPCindex_g[12*2];
  WebRtc_Word16 tmp_fre[FRAMESAMPLES], tmp_fim[FRAMESAMPLES];

  /* Sanity Check - possible values for BWnumber is 0 - 23 */
  if ((BWnumber < 0) || (BWnumber > 23)) {
    return -ISAC_RANGE_ERROR_BW_ESTIMATOR;
  }

  /* reset bitstream */
  ISACBitStr_obj->W_upper = 0xFFFFFFFF;
  ISACBitStr_obj->streamval = 0;
  ISACBitStr_obj->stream_index = 0;

  /* encode frame length */
  status = WebRtcIsac_EncodeFrameLen(ISACSavedEnc_obj->framelength,
                                     ISACBitStr_obj);
  if (status < 0) {
    /* Wrong frame size */
    return status;
  }

  /* Transcoding                                                 */
  if ((scale > 0.0) && (scale < 1.0)) {
    /* Compensate LPC gain */
    for (ii = 0;
         ii < ((ORDERLO + 1)* SUBFRAMES * (1 + ISACSavedEnc_obj->startIdx));
         ii++) {
      tmpLPCcoeffs_lo[ii] = scale *  ISACSavedEnc_obj->LPCcoeffs_lo[ii];
    }
    for (ii = 0;
         ii < ((ORDERHI + 1) * SUBFRAMES *(1 + ISACSavedEnc_obj->startIdx));
         ii++) {
      tmpLPCcoeffs_hi[ii] = scale *  ISACSavedEnc_obj->LPCcoeffs_hi[ii];
    }
    /* Scale DFT */
    for (ii = 0;
         ii < (FRAMESAMPLES_HALF * (1 + ISACSavedEnc_obj->startIdx));
         ii++) {
      tmp_fre[ii] = (WebRtc_Word16)((scale) *
                                    (float)ISACSavedEnc_obj->fre[ii]) ;
      tmp_fim[ii] = (WebRtc_Word16)((scale) *
                                    (float)ISACSavedEnc_obj->fim[ii]) ;
    }
  } else {
    for (ii = 0;
         ii < (KLT_ORDER_GAIN * (1 + ISACSavedEnc_obj->startIdx));
         ii++) {
      tmpLPCindex_g[ii] =  ISACSavedEnc_obj->LPCindex_g[ii];
    }
    for (ii = 0;
         ii < (FRAMESAMPLES_HALF * (1 + ISACSavedEnc_obj->startIdx));
         ii++) {
      tmp_fre[ii] = ISACSavedEnc_obj->fre[ii];
      tmp_fim[ii] = ISACSavedEnc_obj->fim[ii];
    }
  }

  /* encode bandwidth estimate */
  WebRtcIsac_EncodeReceiveBw(&BWno, ISACBitStr_obj);

  /* Loop over number of 30 msec */
  for (ii = 0; ii <= ISACSavedEnc_obj->startIdx; ii++) {
    /* encode pitch gains */
    *WebRtcIsac_kQPitchGainCdf_ptr = WebRtcIsac_kQPitchGainCdf;
    WebRtcIsac_EncHistMulti(ISACBitStr_obj,
                            &ISACSavedEnc_obj->pitchGain_index[ii], WebRtcIsac_kQPitchGainCdf_ptr, 1);

    /* entropy coding of quantization pitch lags */
    /* voicing classificiation */
    if (ISACSavedEnc_obj->meanGain[ii] < 0.2) {
      cdf = WebRtcIsac_kQPitchLagCdfPtrLo;
    } else if (ISACSavedEnc_obj->meanGain[ii] < 0.4) {
      cdf = WebRtcIsac_kQPitchLagCdfPtrMid;
    } else {
      cdf = WebRtcIsac_kQPitchLagCdfPtrHi;
    }
    WebRtcIsac_EncHistMulti(ISACBitStr_obj,
                            &ISACSavedEnc_obj->pitchIndex[PITCH_SUBFRAMES*ii], cdf,
                            PITCH_SUBFRAMES);

    /* LPC */
    /* entropy coding of model number */
    WebRtcIsac_EncHistMulti(ISACBitStr_obj,
                            &ISACSavedEnc_obj->LPCmodel[ii], WebRtcIsac_kQKltModelCdfPtr, 1);

    /* entropy coding of quantization indices - LPC shape only */
    WebRtcIsac_EncHistMulti(ISACBitStr_obj,
                            &ISACSavedEnc_obj->LPCindex_s[KLT_ORDER_SHAPE*ii],
                            WebRtcIsac_kQKltCdfPtrShape[ISACSavedEnc_obj->LPCmodel[ii]],
                            KLT_ORDER_SHAPE);

    /* If transcoding, get new LPC gain indices */
    if (scale < 1.0) {
      WebRtcIsac_TranscodeLPCCoef(&tmpLPCcoeffs_lo[(ORDERLO+1) *
                                                   SUBFRAMES*ii], &tmpLPCcoeffs_hi[(ORDERHI+1)*SUBFRAMES*ii],
                                  ISACSavedEnc_obj->LPCmodel[ii],
                                  &tmpLPCindex_g[KLT_ORDER_GAIN * ii]);
    }

    /* entropy coding of quantization indices - LPC gain */
    WebRtcIsac_EncHistMulti(ISACBitStr_obj,
                            &tmpLPCindex_g[KLT_ORDER_GAIN*ii], WebRtcIsac_kQKltCdfPtrGain[
                                ISACSavedEnc_obj->LPCmodel[ii]], KLT_ORDER_GAIN);

    /* quantization and lossless coding */
    status = WebRtcIsac_EncodeSpecLb(&tmp_fre[ii*FRAMESAMPLES_HALF],
                                     &tmp_fim[ii*FRAMESAMPLES_HALF], ISACBitStr_obj,
                                     ISACSavedEnc_obj->AvgPitchGain[ii]);
    if (status < 0) {
      return status;
    }
  }

  /* complete arithmetic coding */
  return WebRtcIsac_EncTerminate(ISACBitStr_obj);
}




int WebRtcIsac_EncodeStoredDataUb12(
    const ISACUBSaveEncDataStruct* ISACSavedEnc_obj,
    Bitstr*                        bitStream,
    WebRtc_Word32                    jitterInfo,
    float                          scale)
{
  int n;
  int err;
  double lpcGain[SUBFRAMES];
  WebRtc_Word16 realFFT[FRAMESAMPLES_HALF];
  WebRtc_Word16 imagFFT[FRAMESAMPLES_HALF];

  /* reset bitstream */
  bitStream->W_upper = 0xFFFFFFFF;
  bitStream->streamval = 0;
  bitStream->stream_index = 0;

  // Encode jitter index
  WebRtcIsac_EncodeJitterInfo(jitterInfo, bitStream);

  err = WebRtcIsac_EncodeBandwidth(isac12kHz, bitStream);
  if(err < 0)
  {
    return err;
  }

  // Encode LPC-shape
  WebRtcIsac_EncHistMulti(bitStream, ISACSavedEnc_obj->indexLPCShape,
                          WebRtcIsac_kLpcShapeCdfMatUb12, UB_LPC_ORDER * UB_LPC_VEC_PER_FRAME);


  // we only consider scales between zero and one.
  if((scale <= 0.0) || (scale > 1.0))
  {
    scale = 1.0f;
  }

  if(scale == 1.0f)
  {
    //memcpy(lpcGain, ISACSavedEnc_obj->lpcGain, SUBFRAMES * sizeof(double));
    WebRtcIsac_EncHistMulti(bitStream, ISACSavedEnc_obj->lpcGainIndex,
                            WebRtcIsac_kLpcGainCdfMat, UB_LPC_GAIN_DIM);
    // store FFT coefficients
    err = WebRtcIsac_EncodeSpecUB12(ISACSavedEnc_obj->realFFT,
                                      ISACSavedEnc_obj->imagFFT, bitStream);
  }
  else
  {
    /* scale lpc gain and FFT coefficients */
    for(n = 0; n < SUBFRAMES; n++)
    {
      lpcGain[n] = scale * ISACSavedEnc_obj->lpcGain[n];
    }
    // store lpc gain
    WebRtcIsac_StoreLpcGainUb(lpcGain, bitStream);
    for(n = 0; n < FRAMESAMPLES_HALF; n++)
    {
      realFFT[n] = (WebRtc_Word16)(scale * (float)ISACSavedEnc_obj->realFFT[n] + 0.5f);
      imagFFT[n] = (WebRtc_Word16)(scale * (float)ISACSavedEnc_obj->imagFFT[n] + 0.5f);
    }
    // store FFT coefficients
    err = WebRtcIsac_EncodeSpecUB12(realFFT, imagFFT, bitStream);
  }
  if(err < 0)
  {
    // error happened while encoding FFT coefficients.
    return err;
  }

  /* complete arithmetic coding */
  return WebRtcIsac_EncTerminate(bitStream);
}


int
WebRtcIsac_EncodeStoredDataUb16(
    const ISACUBSaveEncDataStruct* ISACSavedEnc_obj,
    Bitstr*                        bitStream,
    WebRtc_Word32                    jitterInfo,
    float                          scale)
{
  int n;
  int err;
  double lpcGain[SUBFRAMES << 1];
  WebRtc_Word16 realFFT[FRAMESAMPLES_HALF];
  WebRtc_Word16 imagFFT[FRAMESAMPLES_HALF];

  /* reset bitstream */
  bitStream->W_upper = 0xFFFFFFFF;
  bitStream->streamval = 0;
  bitStream->stream_index = 0;

  // Encode jitter index
  WebRtcIsac_EncodeJitterInfo(jitterInfo, bitStream);

  err = WebRtcIsac_EncodeBandwidth(isac16kHz, bitStream);
  if(err < 0)
  {
    return err;
  }

  WebRtcIsac_EncHistMulti(bitStream, ISACSavedEnc_obj->indexLPCShape,
                          WebRtcIsac_kLpcShapeCdfMatUb16, UB_LPC_ORDER * UB16_LPC_VEC_PER_FRAME);

  // we only consider scales between zero and one.
  if((scale <= 0.0) || (scale > 1.0))
  {
    scale = 1.0f;
  }

  if(scale == 1.0f)
  {
    // store gains
    WebRtcIsac_EncHistMulti(bitStream, ISACSavedEnc_obj->lpcGainIndex,
                            WebRtcIsac_kLpcGainCdfMat, UB_LPC_GAIN_DIM);
    WebRtcIsac_EncHistMulti(bitStream, &ISACSavedEnc_obj->lpcGainIndex[SUBFRAMES],
                            WebRtcIsac_kLpcGainCdfMat, UB_LPC_GAIN_DIM);
    // store FFT coefficients
    err = WebRtcIsac_EncodeSpecUB16(ISACSavedEnc_obj->realFFT,
                                      ISACSavedEnc_obj->imagFFT, bitStream);

  }
  else
  {
    /* Scale Gain */
    for(n = 0; n < SUBFRAMES; n++)
    {
      lpcGain[n] = scale * ISACSavedEnc_obj->lpcGain[n];
      lpcGain[n + SUBFRAMES] = scale * ISACSavedEnc_obj->lpcGain[n + SUBFRAMES];
    }
    // store lpc gain
    WebRtcIsac_StoreLpcGainUb(lpcGain, bitStream);
    WebRtcIsac_StoreLpcGainUb(&lpcGain[SUBFRAMES], bitStream);
    /* scale FFT coefficients */
    for(n = 0; n < FRAMESAMPLES_HALF; n++)
    {
      realFFT[n] = (WebRtc_Word16)(scale * (float)ISACSavedEnc_obj->realFFT[n] + 0.5f);
      imagFFT[n] = (WebRtc_Word16)(scale * (float)ISACSavedEnc_obj->imagFFT[n] + 0.5f);
    }
    // store FFT coefficients
    err = WebRtcIsac_EncodeSpecUB16(realFFT, imagFFT, bitStream);
  }

  if(err < 0)
  {
    // error happened while encoding FFT coefficients.
    return err;
  }

  /* complete arithmetic coding */
  return WebRtcIsac_EncTerminate(bitStream);
}


WebRtc_Word16
WebRtcIsac_GetRedPayloadUb(
    const ISACUBSaveEncDataStruct* ISACSavedEncObj,
    Bitstr*                        bitStreamObj,
    enum ISACBandwidth             bandwidth)
{
  int n;
  WebRtc_Word16 status;
  WebRtc_Word16 realFFT[FRAMESAMPLES_HALF];
  WebRtc_Word16 imagFFT[FRAMESAMPLES_HALF];

  // store bit-stream object.
  memcpy(bitStreamObj, &ISACSavedEncObj->bitStreamObj, sizeof(Bitstr));

  // Scale FFT coefficients.
  for(n = 0; n < FRAMESAMPLES_HALF; n++)
  {
    realFFT[n] = (WebRtc_Word16)((float)ISACSavedEncObj->realFFT[n] *
                                 RCU_TRANSCODING_SCALE_UB + 0.5);
    imagFFT[n] = (WebRtc_Word16)((float)ISACSavedEncObj->imagFFT[n] *
                                 RCU_TRANSCODING_SCALE_UB + 0.5);
  }

  switch(bandwidth)
  {
    case isac12kHz:
      {
        status = WebRtcIsac_EncodeSpecUB12(realFFT, imagFFT, bitStreamObj);
        break;
      }
    case isac16kHz:
      {
        status = WebRtcIsac_EncodeSpecUB16(realFFT, imagFFT, bitStreamObj);
        break;
      }
    default:
      return -1;
  }

  if(status < 0)
  {
    // error happened
    return status;
  }
  else
  {
    // terminate entropy coding
    return WebRtcIsac_EncTerminate(bitStreamObj);
  }
}
