diff --git a/meson.build b/meson.build
index ca3ce8d..076f8f3 100644
--- a/meson.build
+++ b/meson.build
@@ -111,3 +111,15 @@ pkgconfig.generate(
     ] + platform_cflags,
     libraries: libwebrtc_audio_processing,
 )
+
+pkgconfig.generate(
+    name: 'webrtc-audio-coding',
+    description: 'WebRTC Audio Coding library',
+    version: meson.project_version(),
+    filebase: 'webrtc-audio-coding',
+    subdirs: 'webrtc_audio_processing',
+    extra_cflags: [
+      '-DWEBRTC_AUDIO_PROCESSING_ONLY_BUILD',
+    ] + platform_cflags,
+    libraries: libwebrtc_audio_coding,
+)
diff --git a/webrtc/modules/audio_coding/codecs/audio_decoder.cc b/webrtc/modules/audio_coding/codecs/audio_decoder.cc
new file mode 100644
index 0000000..08d101c
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/audio_decoder.cc
@@ -0,0 +1,106 @@
+/*
+ *  Copyright (c) 2012 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.
+ */
+
+#include "webrtc/modules/audio_coding/codecs/audio_decoder.h"
+
+#include <assert.h>
+
+#include "webrtc/base/checks.h"
+
+namespace webrtc {
+
+int AudioDecoder::Decode(const uint8_t* encoded, size_t encoded_len,
+                         int sample_rate_hz, size_t max_decoded_bytes,
+                         int16_t* decoded, SpeechType* speech_type) {
+  int duration = PacketDuration(encoded, encoded_len);
+  if (duration >= 0 &&
+      duration * Channels() * sizeof(int16_t) > max_decoded_bytes) {
+    return -1;
+  }
+  return DecodeInternal(encoded, encoded_len, sample_rate_hz, decoded,
+                        speech_type);
+}
+
+int AudioDecoder::DecodeRedundant(const uint8_t* encoded, size_t encoded_len,
+                                  int sample_rate_hz, size_t max_decoded_bytes,
+                                  int16_t* decoded, SpeechType* speech_type) {
+  int duration = PacketDurationRedundant(encoded, encoded_len);
+  if (duration >= 0 &&
+      duration * Channels() * sizeof(int16_t) > max_decoded_bytes) {
+    return -1;
+  }
+  return DecodeRedundantInternal(encoded, encoded_len, sample_rate_hz, decoded,
+                                 speech_type);
+}
+
+int AudioDecoder::DecodeInternal(const uint8_t* encoded, size_t encoded_len,
+                                 int sample_rate_hz, int16_t* decoded,
+                                 SpeechType* speech_type) {
+  return kNotImplemented;
+}
+
+int AudioDecoder::DecodeRedundantInternal(const uint8_t* encoded,
+                                          size_t encoded_len,
+                                          int sample_rate_hz, int16_t* decoded,
+                                          SpeechType* speech_type) {
+  return DecodeInternal(encoded, encoded_len, sample_rate_hz, decoded,
+                        speech_type);
+}
+
+bool AudioDecoder::HasDecodePlc() const { return false; }
+
+size_t AudioDecoder::DecodePlc(size_t num_frames, int16_t* decoded) {
+  return 0;
+}
+
+int AudioDecoder::IncomingPacket(const uint8_t* payload,
+                                 size_t payload_len,
+                                 uint16_t rtp_sequence_number,
+                                 uint32_t rtp_timestamp,
+                                 uint32_t arrival_timestamp) {
+  return 0;
+}
+
+int AudioDecoder::ErrorCode() { return 0; }
+
+int AudioDecoder::PacketDuration(const uint8_t* encoded,
+                                 size_t encoded_len) const {
+  return kNotImplemented;
+}
+
+int AudioDecoder::PacketDurationRedundant(const uint8_t* encoded,
+                                          size_t encoded_len) const {
+  return kNotImplemented;
+}
+
+bool AudioDecoder::PacketHasFec(const uint8_t* encoded,
+                                size_t encoded_len) const {
+  return false;
+}
+
+CNG_dec_inst* AudioDecoder::CngDecoderInstance() {
+  FATAL() << "Not a CNG decoder";
+  return NULL;
+}
+
+AudioDecoder::SpeechType AudioDecoder::ConvertSpeechType(int16_t type) {
+  switch (type) {
+    case 0:  // TODO(hlundin): Both iSAC and Opus return 0 for speech.
+    case 1:
+      return kSpeech;
+    case 2:
+      return kComfortNoise;
+    default:
+      assert(false);
+      return kSpeech;
+  }
+}
+
+}  // namespace webrtc
diff --git a/webrtc/modules/audio_coding/codecs/audio_decoder.h b/webrtc/modules/audio_coding/codecs/audio_decoder.h
new file mode 100644
index 0000000..6189be0
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/audio_decoder.h
@@ -0,0 +1,123 @@
+/*
+ *  Copyright (c) 2012 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.
+ */
+
+#ifndef WEBRTC_MODULES_AUDIO_CODING_NETEQ_INCLUDE_AUDIO_DECODER_H_
+#define WEBRTC_MODULES_AUDIO_CODING_NETEQ_INCLUDE_AUDIO_DECODER_H_
+
+#include <stdlib.h>  // NULL
+
+#include "webrtc/base/constructormagic.h"
+#include "webrtc/modules/audio_coding/codecs/cng/include/webrtc_cng.h"
+#include "webrtc/typedefs.h"
+
+namespace webrtc {
+
+// This is the interface class for decoders in NetEQ. Each codec type will have
+// and implementation of this class.
+class AudioDecoder {
+ public:
+  enum SpeechType {
+    kSpeech = 1,
+    kComfortNoise = 2
+  };
+
+  // Used by PacketDuration below. Save the value -1 for errors.
+  enum { kNotImplemented = -2 };
+
+  AudioDecoder() = default;
+  virtual ~AudioDecoder() = default;
+
+  // Decodes |encode_len| bytes from |encoded| and writes the result in
+  // |decoded|. The maximum bytes allowed to be written into |decoded| is
+  // |max_decoded_bytes|. Returns the total number of samples across all
+  // channels. If the decoder produced comfort noise, |speech_type|
+  // is set to kComfortNoise, otherwise it is kSpeech. The desired output
+  // sample rate is provided in |sample_rate_hz|, which must be valid for the
+  // codec at hand.
+  virtual int Decode(const uint8_t* encoded,
+                     size_t encoded_len,
+                     int sample_rate_hz,
+                     size_t max_decoded_bytes,
+                     int16_t* decoded,
+                     SpeechType* speech_type);
+
+  // Same as Decode(), but interfaces to the decoders redundant decode function.
+  // The default implementation simply calls the regular Decode() method.
+  virtual int DecodeRedundant(const uint8_t* encoded,
+                              size_t encoded_len,
+                              int sample_rate_hz,
+                              size_t max_decoded_bytes,
+                              int16_t* decoded,
+                              SpeechType* speech_type);
+
+  // Indicates if the decoder implements the DecodePlc method.
+  virtual bool HasDecodePlc() const;
+
+  // Calls the packet-loss concealment of the decoder to update the state after
+  // one or several lost packets. The caller has to make sure that the
+  // memory allocated in |decoded| should accommodate |num_frames| frames.
+  virtual size_t DecodePlc(size_t num_frames, int16_t* decoded);
+
+  // Resets the decoder state (empty buffers etc.).
+  virtual void Reset() = 0;
+
+  // Notifies the decoder of an incoming packet to NetEQ.
+  virtual int IncomingPacket(const uint8_t* payload,
+                             size_t payload_len,
+                             uint16_t rtp_sequence_number,
+                             uint32_t rtp_timestamp,
+                             uint32_t arrival_timestamp);
+
+  // Returns the last error code from the decoder.
+  virtual int ErrorCode();
+
+  // Returns the duration in samples-per-channel of the payload in |encoded|
+  // which is |encoded_len| bytes long. Returns kNotImplemented if no duration
+  // estimate is available, or -1 in case of an error.
+  virtual int PacketDuration(const uint8_t* encoded, size_t encoded_len) const;
+
+  // Returns the duration in samples-per-channel of the redandant payload in
+  // |encoded| which is |encoded_len| bytes long. Returns kNotImplemented if no
+  // duration estimate is available, or -1 in case of an error.
+  virtual int PacketDurationRedundant(const uint8_t* encoded,
+                                      size_t encoded_len) const;
+
+  // Detects whether a packet has forward error correction. The packet is
+  // comprised of the samples in |encoded| which is |encoded_len| bytes long.
+  // Returns true if the packet has FEC and false otherwise.
+  virtual bool PacketHasFec(const uint8_t* encoded, size_t encoded_len) const;
+
+  // If this is a CNG decoder, return the underlying CNG_dec_inst*. If this
+  // isn't a CNG decoder, don't call this method.
+  virtual CNG_dec_inst* CngDecoderInstance();
+
+  virtual size_t Channels() const = 0;
+
+ protected:
+  static SpeechType ConvertSpeechType(int16_t type);
+
+  virtual int DecodeInternal(const uint8_t* encoded,
+                             size_t encoded_len,
+                             int sample_rate_hz,
+                             int16_t* decoded,
+                             SpeechType* speech_type);
+
+  virtual int DecodeRedundantInternal(const uint8_t* encoded,
+                                      size_t encoded_len,
+                                      int sample_rate_hz,
+                                      int16_t* decoded,
+                                      SpeechType* speech_type);
+
+ private:
+  RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoder);
+};
+
+}  // namespace webrtc
+#endif  // WEBRTC_MODULES_AUDIO_CODING_NETEQ_INCLUDE_AUDIO_DECODER_H_
diff --git a/webrtc/modules/audio_coding/codecs/audio_encoder.cc b/webrtc/modules/audio_coding/codecs/audio_encoder.cc
new file mode 100644
index 0000000..6d76300
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/audio_encoder.cc
@@ -0,0 +1,55 @@
+/*
+ *  Copyright (c) 2014 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.
+ */
+
+#include "webrtc/modules/audio_coding/codecs/audio_encoder.h"
+#include "webrtc/base/checks.h"
+
+namespace webrtc {
+
+AudioEncoder::EncodedInfo::EncodedInfo() = default;
+
+AudioEncoder::EncodedInfo::~EncodedInfo() = default;
+
+int AudioEncoder::RtpTimestampRateHz() const {
+  return SampleRateHz();
+}
+
+AudioEncoder::EncodedInfo AudioEncoder::Encode(uint32_t rtp_timestamp,
+                                               const int16_t* audio,
+                                               size_t num_samples_per_channel,
+                                               size_t max_encoded_bytes,
+                                               uint8_t* encoded) {
+  RTC_CHECK_EQ(num_samples_per_channel,
+               static_cast<size_t>(SampleRateHz() / 100));
+  EncodedInfo info =
+      EncodeInternal(rtp_timestamp, audio, max_encoded_bytes, encoded);
+  RTC_CHECK_LE(info.encoded_bytes, max_encoded_bytes);
+  return info;
+}
+
+bool AudioEncoder::SetFec(bool enable) {
+  return !enable;
+}
+
+bool AudioEncoder::SetDtx(bool enable) {
+  return !enable;
+}
+
+bool AudioEncoder::SetApplication(Application application) {
+  return false;
+}
+
+void AudioEncoder::SetMaxPlaybackRate(int frequency_hz) {}
+
+void AudioEncoder::SetProjectedPacketLossRate(double fraction) {}
+
+void AudioEncoder::SetTargetBitrate(int target_bps) {}
+
+}  // namespace webrtc
diff --git a/webrtc/modules/audio_coding/codecs/audio_encoder.h b/webrtc/modules/audio_coding/codecs/audio_encoder.h
new file mode 100644
index 0000000..cda9d86
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/audio_encoder.h
@@ -0,0 +1,143 @@
+/*
+ *  Copyright (c) 2014 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.
+ */
+
+#ifndef WEBRTC_MODULES_AUDIO_CODING_CODECS_AUDIO_ENCODER_H_
+#define WEBRTC_MODULES_AUDIO_CODING_CODECS_AUDIO_ENCODER_H_
+
+#include <algorithm>
+#include <vector>
+
+#include "webrtc/typedefs.h"
+
+namespace webrtc {
+
+// This is the interface class for encoders in AudioCoding module. Each codec
+// type must have an implementation of this class.
+class AudioEncoder {
+ public:
+  struct EncodedInfoLeaf {
+    size_t encoded_bytes = 0;
+    uint32_t encoded_timestamp = 0;
+    int payload_type = 0;
+    bool send_even_if_empty = false;
+    bool speech = true;
+  };
+
+  // This is the main struct for auxiliary encoding information. Each encoded
+  // packet should be accompanied by one EncodedInfo struct, containing the
+  // total number of |encoded_bytes|, the |encoded_timestamp| and the
+  // |payload_type|. If the packet contains redundant encodings, the |redundant|
+  // vector will be populated with EncodedInfoLeaf structs. Each struct in the
+  // vector represents one encoding; the order of structs in the vector is the
+  // same as the order in which the actual payloads are written to the byte
+  // stream. When EncoderInfoLeaf structs are present in the vector, the main
+  // struct's |encoded_bytes| will be the sum of all the |encoded_bytes| in the
+  // vector.
+  struct EncodedInfo : public EncodedInfoLeaf {
+    EncodedInfo();
+    ~EncodedInfo();
+
+    std::vector<EncodedInfoLeaf> redundant;
+  };
+
+  virtual ~AudioEncoder() = default;
+
+  // Returns the maximum number of bytes that can be produced by the encoder
+  // at each Encode() call. The caller can use the return value to determine
+  // the size of the buffer that needs to be allocated. This value is allowed
+  // to depend on encoder parameters like bitrate, frame size etc., so if
+  // any of these change, the caller of Encode() is responsible for checking
+  // that the buffer is large enough by calling MaxEncodedBytes() again.
+  virtual size_t MaxEncodedBytes() const = 0;
+
+  // Returns the input sample rate in Hz and the number of input channels.
+  // These are constants set at instantiation time.
+  virtual int SampleRateHz() const = 0;
+  virtual int NumChannels() const = 0;
+
+  // Returns the rate at which the RTP timestamps are updated. The default
+  // implementation returns SampleRateHz().
+  virtual int RtpTimestampRateHz() const;
+
+  // Returns the number of 10 ms frames the encoder will put in the next
+  // packet. This value may only change when Encode() outputs a packet; i.e.,
+  // the encoder may vary the number of 10 ms frames from packet to packet, but
+  // it must decide the length of the next packet no later than when outputting
+  // the preceding packet.
+  virtual size_t Num10MsFramesInNextPacket() const = 0;
+
+  // Returns the maximum value that can be returned by
+  // Num10MsFramesInNextPacket().
+  virtual size_t Max10MsFramesInAPacket() const = 0;
+
+  // Returns the current target bitrate in bits/s. The value -1 means that the
+  // codec adapts the target automatically, and a current target cannot be
+  // provided.
+  virtual int GetTargetBitrate() const = 0;
+
+  // Accepts one 10 ms block of input audio (i.e., SampleRateHz() / 100 *
+  // NumChannels() samples). Multi-channel audio must be sample-interleaved.
+  // The encoder produces zero or more bytes of output in |encoded| and
+  // returns additional encoding information.
+  // The caller is responsible for making sure that |max_encoded_bytes| is
+  // not smaller than the number of bytes actually produced by the encoder.
+  // Encode() checks some preconditions, calls EncodeInternal() which does the
+  // actual work, and then checks some postconditions.
+  EncodedInfo Encode(uint32_t rtp_timestamp,
+                     const int16_t* audio,
+                     size_t num_samples_per_channel,
+                     size_t max_encoded_bytes,
+                     uint8_t* encoded);
+
+  virtual EncodedInfo EncodeInternal(uint32_t rtp_timestamp,
+                                     const int16_t* audio,
+                                     size_t max_encoded_bytes,
+                                     uint8_t* encoded) = 0;
+
+  // Resets the encoder to its starting state, discarding any input that has
+  // been fed to the encoder but not yet emitted in a packet.
+  virtual void Reset() = 0;
+
+  // Enables or disables codec-internal FEC (forward error correction). Returns
+  // true if the codec was able to comply. The default implementation returns
+  // true when asked to disable FEC and false when asked to enable it (meaning
+  // that FEC isn't supported).
+  virtual bool SetFec(bool enable);
+
+  // Enables or disables codec-internal VAD/DTX. Returns true if the codec was
+  // able to comply. The default implementation returns true when asked to
+  // disable DTX and false when asked to enable it (meaning that DTX isn't
+  // supported).
+  virtual bool SetDtx(bool enable);
+
+  // Sets the application mode. Returns true if the codec was able to comply.
+  // The default implementation just returns false.
+  enum class Application { kSpeech, kAudio };
+  virtual bool SetApplication(Application application);
+
+  // Tells the encoder about the highest sample rate the decoder is expected to
+  // use when decoding the bitstream. The encoder would typically use this
+  // information to adjust the quality of the encoding. The default
+  // implementation just returns true.
+  virtual void SetMaxPlaybackRate(int frequency_hz);
+
+  // Tells the encoder what the projected packet loss rate is. The rate is in
+  // the range [0.0, 1.0]. The encoder would typically use this information to
+  // adjust channel coding efforts, such as FEC. The default implementation
+  // does nothing.
+  virtual void SetProjectedPacketLossRate(double fraction);
+
+  // Tells the encoder what average bitrate we'd like it to produce. The
+  // encoder is free to adjust or disregard the given bitrate (the default
+  // implementation does the latter).
+  virtual void SetTargetBitrate(int target_bps);
+};
+}  // namespace webrtc
+#endif  // WEBRTC_MODULES_AUDIO_CODING_CODECS_AUDIO_ENCODER_H_
diff --git a/webrtc/modules/audio_coding/codecs/cng/include/webrtc_cng.h b/webrtc/modules/audio_coding/codecs/cng/include/webrtc_cng.h
new file mode 100644
index 0000000..35660c4
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/cng/include/webrtc_cng.h
@@ -0,0 +1,163 @@
+/*
+ *  Copyright (c) 2012 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.
+ */
+
+
+#ifndef WEBRTC_MODULES_AUDIO_CODING_CODECS_CNG_MAIN_INCLUDE_WEBRTC_CNG_H_
+#define WEBRTC_MODULES_AUDIO_CODING_CODECS_CNG_MAIN_INCLUDE_WEBRTC_CNG_H_
+
+#include <stddef.h>
+#include "webrtc/typedefs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define WEBRTC_CNG_MAX_LPC_ORDER 12
+#define WEBRTC_CNG_MAX_OUTSIZE_ORDER 640
+
+/* Define Error codes. */
+
+/* 6100 Encoder */
+#define CNG_ENCODER_NOT_INITIATED               6120
+#define CNG_DISALLOWED_LPC_ORDER                6130
+#define CNG_DISALLOWED_FRAME_SIZE               6140
+#define CNG_DISALLOWED_SAMPLING_FREQUENCY       6150
+/* 6200 Decoder */
+#define CNG_DECODER_NOT_INITIATED               6220
+
+typedef struct WebRtcCngEncInst CNG_enc_inst;
+typedef struct WebRtcCngDecInst CNG_dec_inst;
+
+/****************************************************************************
+ * WebRtcCng_CreateEnc/Dec(...)
+ *
+ * These functions create an instance to the specified structure
+ *
+ * Input:
+ *    - XXX_inst      : Pointer to created instance that should be created
+ *
+ * Return value       :  0 - Ok
+ *                      -1 - Error
+ */
+int16_t WebRtcCng_CreateEnc(CNG_enc_inst** cng_inst);
+int16_t WebRtcCng_CreateDec(CNG_dec_inst** cng_inst);
+
+/****************************************************************************
+ * WebRtcCng_InitEnc/Dec(...)
+ *
+ * This function initializes a instance
+ *
+ * Input:
+ *    - cng_inst      : Instance that should be initialized
+ *
+ *    - fs            : 8000 for narrowband and 16000 for wideband
+ *    - interval      : generate SID data every interval ms
+ *    - quality       : Number of refl. coefs, maximum allowed is 12
+ *
+ * Output:
+ *    - cng_inst      : Initialized instance
+ *
+ * Return value       :  0 - Ok
+ *                      -1 - Error
+ */
+
+int WebRtcCng_InitEnc(CNG_enc_inst* cng_inst, int fs, int16_t interval,
+                      int16_t quality);
+void WebRtcCng_InitDec(CNG_dec_inst* cng_inst);
+
+/****************************************************************************
+ * WebRtcCng_FreeEnc/Dec(...)
+ *
+ * These functions frees the dynamic memory of a specified instance
+ *
+ * Input:
+ *    - cng_inst      : Pointer to created instance that should be freed
+ *
+ * Return value       :  0 - Ok
+ *                      -1 - Error
+ */
+int16_t WebRtcCng_FreeEnc(CNG_enc_inst* cng_inst);
+int16_t WebRtcCng_FreeDec(CNG_dec_inst* cng_inst);
+
+/****************************************************************************
+ * WebRtcCng_Encode(...)
+ *
+ * These functions analyzes background noise
+ *
+ * Input:
+ *    - cng_inst      : Pointer to created instance
+ *    - speech        : Signal to be analyzed
+ *    - nrOfSamples   : Size of speech vector
+ *    - forceSID      : not zero to force SID frame and reset
+ *
+ * Output:
+ *    - bytesOut      : Nr of bytes to transmit, might be 0
+ *
+ * Return value       :  0 - Ok
+ *                      -1 - Error
+ */
+int WebRtcCng_Encode(CNG_enc_inst* cng_inst, int16_t* speech,
+                     size_t nrOfSamples, uint8_t* SIDdata,
+                     size_t* bytesOut, int16_t forceSID);
+
+/****************************************************************************
+ * WebRtcCng_UpdateSid(...)
+ *
+ * These functions updates the CN state, when a new SID packet arrives
+ *
+ * Input:
+ *    - cng_inst      : Pointer to created instance that should be freed
+ *    - SID           : SID packet, all headers removed
+ *    - length        : Length in bytes of SID packet
+ *
+ * Return value       :  0 - Ok
+ *                      -1 - Error
+ */
+int16_t WebRtcCng_UpdateSid(CNG_dec_inst* cng_inst, uint8_t* SID,
+                            size_t length);
+
+/****************************************************************************
+ * WebRtcCng_Generate(...)
+ *
+ * These functions generates CN data when needed
+ *
+ * Input:
+ *    - cng_inst      : Pointer to created instance that should be freed
+ *    - outData       : pointer to area to write CN data
+ *    - nrOfSamples   : How much data to generate
+ *    - new_period    : >0 if a new period of CNG, will reset history
+ *
+ * Return value       :  0 - Ok
+ *                      -1 - Error
+ */
+int16_t WebRtcCng_Generate(CNG_dec_inst* cng_inst, int16_t* outData,
+                           size_t nrOfSamples, int16_t new_period);
+
+/*****************************************************************************
+ * WebRtcCng_GetErrorCodeEnc/Dec(...)
+ *
+ * This functions can be used to check the error code of a CNG instance. When
+ * a function returns -1 a error code will be set for that instance. The 
+ * function below extract the code of the last error that occurred in the
+ * specified instance.
+ *
+ * Input:
+ *    - CNG_inst    : CNG enc/dec instance
+ *
+ * Return value     : Error code
+ */
+int16_t WebRtcCng_GetErrorCodeEnc(CNG_enc_inst* cng_inst);
+int16_t WebRtcCng_GetErrorCodeDec(CNG_dec_inst* cng_inst);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // WEBRTC_MODULES_AUDIO_CODING_CODECS_CNG_MAIN_INCLUDE_WEBRTC_CNG_H_
diff --git a/webrtc/modules/audio_coding/codecs/isac/audio_decoder_isac_t.h b/webrtc/modules/audio_coding/codecs/isac/audio_decoder_isac_t.h
new file mode 100644
index 0000000..845af42
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/audio_decoder_isac_t.h
@@ -0,0 +1,54 @@
+/*
+ *  Copyright (c) 2015 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.
+ */
+
+#ifndef WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_AUDIO_DECODER_ISAC_T_H_
+#define WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_AUDIO_DECODER_ISAC_T_H_
+
+#include <vector>
+
+#include "webrtc/modules/audio_coding/codecs/audio_decoder.h"
+#include "webrtc/modules/audio_coding/codecs/isac/locked_bandwidth_info.h"
+
+namespace webrtc {
+
+template <typename T>
+class AudioDecoderIsacT final : public AudioDecoder {
+ public:
+  AudioDecoderIsacT();
+  explicit AudioDecoderIsacT(LockedIsacBandwidthInfo* bwinfo);
+  ~AudioDecoderIsacT() override;
+
+  bool HasDecodePlc() const override;
+  size_t DecodePlc(size_t num_frames, int16_t* decoded) override;
+  void Reset() override;
+  int IncomingPacket(const uint8_t* payload,
+                     size_t payload_len,
+                     uint16_t rtp_sequence_number,
+                     uint32_t rtp_timestamp,
+                     uint32_t arrival_timestamp) override;
+  int ErrorCode() override;
+  size_t Channels() const override;
+  int DecodeInternal(const uint8_t* encoded,
+                     size_t encoded_len,
+                     int sample_rate_hz,
+                     int16_t* decoded,
+                     SpeechType* speech_type) override;
+
+ private:
+  typename T::instance_type* isac_state_;
+  LockedIsacBandwidthInfo* bwinfo_;
+  int decoder_sample_rate_hz_;
+
+  RTC_DISALLOW_COPY_AND_ASSIGN(AudioDecoderIsacT);
+};
+
+}  // namespace webrtc
+
+#endif  // WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_AUDIO_DECODER_ISAC_T_H_
diff --git a/webrtc/modules/audio_coding/codecs/isac/audio_decoder_isac_t_impl.h b/webrtc/modules/audio_coding/codecs/isac/audio_decoder_isac_t_impl.h
new file mode 100644
index 0000000..a986bc4
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/audio_decoder_isac_t_impl.h
@@ -0,0 +1,104 @@
+/*
+ *  Copyright (c) 2015 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.
+ */
+
+#ifndef WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_AUDIO_DECODER_ISAC_T_IMPL_H_
+#define WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_AUDIO_DECODER_ISAC_T_IMPL_H_
+
+#include "webrtc/modules/audio_coding/codecs/isac/main/include/audio_decoder_isac.h"
+
+#include "webrtc/base/checks.h"
+
+namespace webrtc {
+
+template <typename T>
+AudioDecoderIsacT<T>::AudioDecoderIsacT()
+    : AudioDecoderIsacT(nullptr) {}
+
+template <typename T>
+AudioDecoderIsacT<T>::AudioDecoderIsacT(LockedIsacBandwidthInfo* bwinfo)
+    : bwinfo_(bwinfo), decoder_sample_rate_hz_(-1) {
+  RTC_CHECK_EQ(0, T::Create(&isac_state_));
+  T::DecoderInit(isac_state_);
+  if (bwinfo_) {
+    IsacBandwidthInfo bi;
+    T::GetBandwidthInfo(isac_state_, &bi);
+    bwinfo_->Set(bi);
+  }
+}
+
+template <typename T>
+AudioDecoderIsacT<T>::~AudioDecoderIsacT() {
+  RTC_CHECK_EQ(0, T::Free(isac_state_));
+}
+
+template <typename T>
+int AudioDecoderIsacT<T>::DecodeInternal(const uint8_t* encoded,
+                                         size_t encoded_len,
+                                         int sample_rate_hz,
+                                         int16_t* decoded,
+                                         SpeechType* speech_type) {
+  RTC_CHECK(sample_rate_hz == 16000 || sample_rate_hz == 32000)
+      << "Unsupported sample rate " << sample_rate_hz;
+  if (sample_rate_hz != decoder_sample_rate_hz_) {
+    RTC_CHECK_EQ(0, T::SetDecSampRate(isac_state_, sample_rate_hz));
+    decoder_sample_rate_hz_ = sample_rate_hz;
+  }
+  int16_t temp_type = 1;  // Default is speech.
+  int ret =
+      T::DecodeInternal(isac_state_, encoded, encoded_len, decoded, &temp_type);
+  *speech_type = ConvertSpeechType(temp_type);
+  return ret;
+}
+
+template <typename T>
+bool AudioDecoderIsacT<T>::HasDecodePlc() const {
+  return false;
+}
+
+template <typename T>
+size_t AudioDecoderIsacT<T>::DecodePlc(size_t num_frames, int16_t* decoded) {
+  return T::DecodePlc(isac_state_, decoded, num_frames);
+}
+
+template <typename T>
+void AudioDecoderIsacT<T>::Reset() {
+  T::DecoderInit(isac_state_);
+}
+
+template <typename T>
+int AudioDecoderIsacT<T>::IncomingPacket(const uint8_t* payload,
+                                         size_t payload_len,
+                                         uint16_t rtp_sequence_number,
+                                         uint32_t rtp_timestamp,
+                                         uint32_t arrival_timestamp) {
+  int ret = T::UpdateBwEstimate(isac_state_, payload, payload_len,
+                                rtp_sequence_number, rtp_timestamp,
+                                arrival_timestamp);
+  if (bwinfo_) {
+    IsacBandwidthInfo bwinfo;
+    T::GetBandwidthInfo(isac_state_, &bwinfo);
+    bwinfo_->Set(bwinfo);
+  }
+  return ret;
+}
+
+template <typename T>
+int AudioDecoderIsacT<T>::ErrorCode() {
+  return T::GetErrorCode(isac_state_);
+}
+
+template <typename T>
+size_t AudioDecoderIsacT<T>::Channels() const {
+  return 1;
+}
+
+}  // namespace webrtc
+
+#endif  // WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_AUDIO_DECODER_ISAC_T_IMPL_H_
diff --git a/webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t.h b/webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t.h
new file mode 100644
index 0000000..b15ad94
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t.h
@@ -0,0 +1,97 @@
+/*
+ *  Copyright (c) 2014 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.
+ */
+
+#ifndef WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_AUDIO_ENCODER_ISAC_T_H_
+#define WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_AUDIO_ENCODER_ISAC_T_H_
+
+#include <vector>
+
+#include "webrtc/modules/audio_coding/codecs/audio_encoder.h"
+#include "webrtc/modules/audio_coding/codecs/isac/locked_bandwidth_info.h"
+
+namespace webrtc {
+
+struct CodecInst;
+
+template <typename T>
+class AudioEncoderIsacT final : public AudioEncoder {
+ public:
+  // Allowed combinations of sample rate, frame size, and bit rate are
+  //  - 16000 Hz, 30 ms, 10000-32000 bps
+  //  - 16000 Hz, 60 ms, 10000-32000 bps
+  //  - 32000 Hz, 30 ms, 10000-56000 bps (if T has super-wideband support)
+  struct Config {
+    bool IsOk() const;
+
+    LockedIsacBandwidthInfo* bwinfo = nullptr;
+
+    int payload_type = 103;
+    int sample_rate_hz = 16000;
+    int frame_size_ms = 30;
+    int bit_rate = kDefaultBitRate;  // Limit on the short-term average bit
+                                     // rate, in bits/s.
+    int max_payload_size_bytes = -1;
+    int max_bit_rate = -1;
+
+    // If true, the encoder will dynamically adjust frame size and bit rate;
+    // the configured values are then merely the starting point.
+    bool adaptive_mode = false;
+
+    // In adaptive mode, prevent adaptive changes to the frame size. (Not used
+    // in nonadaptive mode.)
+    bool enforce_frame_size = false;
+  };
+
+  explicit AudioEncoderIsacT(const Config& config);
+  explicit AudioEncoderIsacT(const CodecInst& codec_inst,
+                             LockedIsacBandwidthInfo* bwinfo);
+  ~AudioEncoderIsacT() override;
+
+  size_t MaxEncodedBytes() const override;
+  int SampleRateHz() const override;
+  int NumChannels() const override;
+  size_t Num10MsFramesInNextPacket() const override;
+  size_t Max10MsFramesInAPacket() const override;
+  int GetTargetBitrate() const override;
+  EncodedInfo EncodeInternal(uint32_t rtp_timestamp,
+                             const int16_t* audio,
+                             size_t max_encoded_bytes,
+                             uint8_t* encoded) override;
+  void Reset() override;
+
+ private:
+  // This value is taken from STREAM_SIZE_MAX_60 for iSAC float (60 ms) and
+  // STREAM_MAXW16_60MS for iSAC fix (60 ms).
+  static const size_t kSufficientEncodeBufferSizeBytes = 400;
+
+  static const int kDefaultBitRate = 32000;
+
+  // Recreate the iSAC encoder instance with the given settings, and save them.
+  void RecreateEncoderInstance(const Config& config);
+
+  Config config_;
+  typename T::instance_type* isac_state_ = nullptr;
+  LockedIsacBandwidthInfo* bwinfo_ = nullptr;
+
+  // Have we accepted input but not yet emitted it in a packet?
+  bool packet_in_progress_ = false;
+
+  // Timestamp of the first input of the currently in-progress packet.
+  uint32_t packet_timestamp_;
+
+  // Timestamp of the previously encoded packet.
+  uint32_t last_encoded_timestamp_;
+
+  RTC_DISALLOW_COPY_AND_ASSIGN(AudioEncoderIsacT);
+};
+
+}  // namespace webrtc
+
+#endif  // WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_AUDIO_ENCODER_ISAC_T_H_
diff --git a/webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t_impl.h b/webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t_impl.h
new file mode 100644
index 0000000..279f80d
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t_impl.h
@@ -0,0 +1,190 @@
+/*
+ *  Copyright (c) 2014 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.
+ */
+
+#ifndef WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_AUDIO_ENCODER_ISAC_T_IMPL_H_
+#define WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_AUDIO_ENCODER_ISAC_T_IMPL_H_
+
+#include "webrtc/modules/audio_coding/codecs/isac/main/include/audio_encoder_isac.h"
+
+#include "webrtc/base/checks.h"
+
+namespace webrtc {
+
+template <typename T>
+typename AudioEncoderIsacT<T>::Config CreateIsacConfig(
+    const CodecInst& codec_inst,
+    LockedIsacBandwidthInfo* bwinfo) {
+  typename AudioEncoderIsacT<T>::Config config;
+  config.bwinfo = bwinfo;
+  config.payload_type = codec_inst.pltype;
+  config.sample_rate_hz = codec_inst.plfreq;
+  config.frame_size_ms =
+      rtc::CheckedDivExact(1000 * codec_inst.pacsize, config.sample_rate_hz);
+  config.adaptive_mode = (codec_inst.rate == -1);
+  if (codec_inst.rate != -1)
+    config.bit_rate = codec_inst.rate;
+  return config;
+}
+
+template <typename T>
+bool AudioEncoderIsacT<T>::Config::IsOk() const {
+  if (max_bit_rate < 32000 && max_bit_rate != -1)
+    return false;
+  if (max_payload_size_bytes < 120 && max_payload_size_bytes != -1)
+    return false;
+  if (adaptive_mode && !bwinfo)
+    return false;
+  switch (sample_rate_hz) {
+    case 16000:
+      if (max_bit_rate > 53400)
+        return false;
+      if (max_payload_size_bytes > 400)
+        return false;
+      return (frame_size_ms == 30 || frame_size_ms == 60) &&
+             (bit_rate == 0 || (bit_rate >= 10000 && bit_rate <= 32000));
+    case 32000:
+      if (max_bit_rate > 160000)
+        return false;
+      if (max_payload_size_bytes > 600)
+        return false;
+      return T::has_swb &&
+             (frame_size_ms == 30 &&
+              (bit_rate == 0 || (bit_rate >= 10000 && bit_rate <= 56000)));
+    default:
+      return false;
+  }
+}
+
+template <typename T>
+AudioEncoderIsacT<T>::AudioEncoderIsacT(const Config& config) {
+  RecreateEncoderInstance(config);
+}
+
+template <typename T>
+AudioEncoderIsacT<T>::AudioEncoderIsacT(const CodecInst& codec_inst,
+                                        LockedIsacBandwidthInfo* bwinfo)
+    : AudioEncoderIsacT(CreateIsacConfig<T>(codec_inst, bwinfo)) {}
+
+template <typename T>
+AudioEncoderIsacT<T>::~AudioEncoderIsacT() {
+  RTC_CHECK_EQ(0, T::Free(isac_state_));
+}
+
+template <typename T>
+size_t AudioEncoderIsacT<T>::MaxEncodedBytes() const {
+  return kSufficientEncodeBufferSizeBytes;
+}
+
+template <typename T>
+int AudioEncoderIsacT<T>::SampleRateHz() const {
+  return T::EncSampRate(isac_state_);
+}
+
+template <typename T>
+int AudioEncoderIsacT<T>::NumChannels() const {
+  return 1;
+}
+
+template <typename T>
+size_t AudioEncoderIsacT<T>::Num10MsFramesInNextPacket() const {
+  const int samples_in_next_packet = T::GetNewFrameLen(isac_state_);
+  return static_cast<size_t>(
+      rtc::CheckedDivExact(samples_in_next_packet,
+                           rtc::CheckedDivExact(SampleRateHz(), 100)));
+}
+
+template <typename T>
+size_t AudioEncoderIsacT<T>::Max10MsFramesInAPacket() const {
+  return 6;  // iSAC puts at most 60 ms in a packet.
+}
+
+template <typename T>
+int AudioEncoderIsacT<T>::GetTargetBitrate() const {
+  if (config_.adaptive_mode)
+    return -1;
+  return config_.bit_rate == 0 ? kDefaultBitRate : config_.bit_rate;
+}
+
+template <typename T>
+AudioEncoder::EncodedInfo AudioEncoderIsacT<T>::EncodeInternal(
+    uint32_t rtp_timestamp,
+    const int16_t* audio,
+    size_t max_encoded_bytes,
+    uint8_t* encoded) {
+  if (!packet_in_progress_) {
+    // Starting a new packet; remember the timestamp for later.
+    packet_in_progress_ = true;
+    packet_timestamp_ = rtp_timestamp;
+  }
+  if (bwinfo_) {
+    IsacBandwidthInfo bwinfo = bwinfo_->Get();
+    T::SetBandwidthInfo(isac_state_, &bwinfo);
+  }
+  int r = T::Encode(isac_state_, audio, encoded);
+  RTC_CHECK_GE(r, 0) << "Encode failed (error code "
+                     << T::GetErrorCode(isac_state_) << ")";
+
+  // T::Encode doesn't allow us to tell it the size of the output
+  // buffer. All we can do is check for an overrun after the fact.
+  RTC_CHECK_LE(static_cast<size_t>(r), max_encoded_bytes);
+
+  if (r == 0)
+    return EncodedInfo();
+
+  // Got enough input to produce a packet. Return the saved timestamp from
+  // the first chunk of input that went into the packet.
+  packet_in_progress_ = false;
+  EncodedInfo info;
+  info.encoded_bytes = r;
+  info.encoded_timestamp = packet_timestamp_;
+  info.payload_type = config_.payload_type;
+  return info;
+}
+
+template <typename T>
+void AudioEncoderIsacT<T>::Reset() {
+  RecreateEncoderInstance(config_);
+}
+
+template <typename T>
+void AudioEncoderIsacT<T>::RecreateEncoderInstance(const Config& config) {
+  RTC_CHECK(config.IsOk());
+  packet_in_progress_ = false;
+  bwinfo_ = config.bwinfo;
+  if (isac_state_)
+    RTC_CHECK_EQ(0, T::Free(isac_state_));
+  RTC_CHECK_EQ(0, T::Create(&isac_state_));
+  RTC_CHECK_EQ(0, T::EncoderInit(isac_state_, config.adaptive_mode ? 0 : 1));
+  RTC_CHECK_EQ(0, T::SetEncSampRate(isac_state_, config.sample_rate_hz));
+  const int bit_rate = config.bit_rate == 0 ? kDefaultBitRate : config.bit_rate;
+  if (config.adaptive_mode) {
+    RTC_CHECK_EQ(0, T::ControlBwe(isac_state_, bit_rate, config.frame_size_ms,
+                                  config.enforce_frame_size));
+  } else {
+    RTC_CHECK_EQ(0, T::Control(isac_state_, bit_rate, config.frame_size_ms));
+  }
+  if (config.max_payload_size_bytes != -1)
+    RTC_CHECK_EQ(
+        0, T::SetMaxPayloadSize(isac_state_, config.max_payload_size_bytes));
+  if (config.max_bit_rate != -1)
+    RTC_CHECK_EQ(0, T::SetMaxRate(isac_state_, config.max_bit_rate));
+
+  // Set the decoder sample rate even though we just use the encoder. This
+  // doesn't appear to be necessary to produce a valid encoding, but without it
+  // we get an encoding that isn't bit-for-bit identical with what a combined
+  // encoder+decoder object produces.
+  RTC_CHECK_EQ(0, T::SetDecSampRate(isac_state_, config.sample_rate_hz));
+
+  config_ = config;
+}
+
+}  // namespace webrtc
+
+#endif  // WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_AUDIO_ENCODER_ISAC_T_IMPL_H_
diff --git a/webrtc/modules/audio_coding/codecs/isac/locked_bandwidth_info.h b/webrtc/modules/audio_coding/codecs/isac/locked_bandwidth_info.h
new file mode 100644
index 0000000..bbb040d
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/locked_bandwidth_info.h
@@ -0,0 +1,45 @@
+/*
+ *  Copyright (c) 2015 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.
+ */
+
+#ifndef WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_LOCKED_BANDWIDTH_INFO_H_
+#define WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_LOCKED_BANDWIDTH_INFO_H_
+
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/thread_annotations.h"
+#include "webrtc/modules/audio_coding/codecs/isac/bandwidth_info.h"
+#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
+
+namespace webrtc {
+
+// An IsacBandwidthInfo that's safe to access from multiple threads because
+// it's protected by a mutex.
+class LockedIsacBandwidthInfo final {
+ public:
+  LockedIsacBandwidthInfo();
+  ~LockedIsacBandwidthInfo();
+
+  IsacBandwidthInfo Get() const {
+    CriticalSectionScoped cs(lock_.get());
+    return bwinfo_;
+  }
+
+  void Set(const IsacBandwidthInfo& bwinfo) {
+    CriticalSectionScoped cs(lock_.get());
+    bwinfo_ = bwinfo;
+  }
+
+ private:
+  const rtc::scoped_ptr<CriticalSectionWrapper> lock_;
+  IsacBandwidthInfo bwinfo_ GUARDED_BY(lock_);
+};
+
+}  // namespace webrtc
+
+#endif  // WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_LOCKED_BANDWIDTH_INFO_H_
diff --git a/webrtc/modules/audio_coding/codecs/isac/main/include/audio_decoder_isac.h b/webrtc/modules/audio_coding/codecs/isac/main/include/audio_decoder_isac.h
new file mode 100644
index 0000000..dcd4852
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/main/include/audio_decoder_isac.h
@@ -0,0 +1,22 @@
+/*
+ *  Copyright (c) 2015 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.
+ */
+
+#ifndef WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_INCLUDE_AUDIO_DECODER_ISAC_H_
+#define WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_INCLUDE_AUDIO_DECODER_ISAC_H_
+
+#include "webrtc/modules/audio_coding/codecs/isac/audio_decoder_isac_t.h"
+#include "webrtc/modules/audio_coding/codecs/isac/main/source/isac_float_type.h"
+
+namespace webrtc {
+
+using AudioDecoderIsac = AudioDecoderIsacT<IsacFloat>;
+
+}  // namespace webrtc
+#endif  // WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_INCLUDE_AUDIO_ENCODER_ISAC_H_
diff --git a/webrtc/modules/audio_coding/codecs/isac/main/include/audio_encoder_isac.h b/webrtc/modules/audio_coding/codecs/isac/main/include/audio_encoder_isac.h
new file mode 100644
index 0000000..cc8665d
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/main/include/audio_encoder_isac.h
@@ -0,0 +1,22 @@
+/*
+ *  Copyright (c) 2014 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.
+ */
+
+#ifndef WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_INCLUDE_AUDIO_ENCODER_ISAC_H_
+#define WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_INCLUDE_AUDIO_ENCODER_ISAC_H_
+
+#include "webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t.h"
+#include "webrtc/modules/audio_coding/codecs/isac/main/source/isac_float_type.h"
+
+namespace webrtc {
+
+using AudioEncoderIsac = AudioEncoderIsacT<IsacFloat>;
+
+}  // namespace webrtc
+#endif  // WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_INCLUDE_AUDIO_ENCODER_ISAC_H_
diff --git a/webrtc/modules/audio_coding/codecs/isac/main/source/audio_decoder_isac.cc b/webrtc/modules/audio_coding/codecs/isac/main/source/audio_decoder_isac.cc
new file mode 100644
index 0000000..8e0603e
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/main/source/audio_decoder_isac.cc
@@ -0,0 +1,20 @@
+/*
+ *  Copyright (c) 2015 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.
+ */
+
+#include "webrtc/modules/audio_coding/codecs/isac/main/include/audio_decoder_isac.h"
+
+#include "webrtc/modules/audio_coding/codecs/isac/audio_decoder_isac_t_impl.h"
+
+namespace webrtc {
+
+// Explicit instantiation:
+template class AudioDecoderIsacT<IsacFloat>;
+
+}  // namespace webrtc
diff --git a/webrtc/modules/audio_coding/codecs/isac/main/source/audio_encoder_isac.cc b/webrtc/modules/audio_coding/codecs/isac/main/source/audio_encoder_isac.cc
new file mode 100644
index 0000000..64b9815
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/main/source/audio_encoder_isac.cc
@@ -0,0 +1,20 @@
+/*
+ *  Copyright (c) 2014 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.
+ */
+
+#include "webrtc/modules/audio_coding/codecs/isac/main/include/audio_encoder_isac.h"
+
+#include "webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t_impl.h"
+
+namespace webrtc {
+
+// Explicit instantiation:
+template class AudioEncoderIsacT<IsacFloat>;
+
+}  // namespace webrtc
diff --git a/webrtc/modules/audio_coding/codecs/isac/main/source/bandwidth_estimator.c b/webrtc/modules/audio_coding/codecs/isac/main/source/bandwidth_estimator.c
new file mode 100644
index 0000000..82fd053
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/main/source/bandwidth_estimator.c
@@ -0,0 +1,1031 @@
+/*
+ *  Copyright (c) 2012 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.
+ */
+
+/*
+ * BwEstimator.c
+ *
+ * This file contains the code for the Bandwidth Estimator designed
+ * for iSAC.
+ *
+ */
+
+#include "bandwidth_estimator.h"
+#include "settings.h"
+#include "webrtc/modules/audio_coding/codecs/isac/main/include/isac.h"
+
+#include <assert.h>
+#include <math.h>
+#include <string.h>
+
+/* array of quantization levels for bottle neck info; Matlab code: */
+/* sprintf('%4.1ff, ', logspace(log10(5000), log10(40000), 12)) */
+static const float kQRateTableWb[12] =
+{
+  10000.0f, 11115.3f, 12355.1f, 13733.1f, 15264.8f, 16967.3f,
+  18859.8f, 20963.3f, 23301.4f, 25900.3f, 28789.0f, 32000.0f};
+
+
+static const float kQRateTableSwb[24] =
+{
+  10000.0f, 11115.3f, 12355.1f, 13733.1f, 15264.8f, 16967.3f,
+  18859.8f, 20963.3f, 23153.1f, 25342.9f, 27532.7f, 29722.5f,
+  31912.3f, 34102.1f, 36291.9f, 38481.7f, 40671.4f, 42861.2f,
+  45051.0f, 47240.8f, 49430.6f, 51620.4f, 53810.2f, 56000.0f,
+};
+
+
+
+
+int32_t WebRtcIsac_InitBandwidthEstimator(
+    BwEstimatorstr*              bwest_str,
+    enum IsacSamplingRate encoderSampRate,
+    enum IsacSamplingRate decoderSampRate)
+{
+  switch(encoderSampRate)
+  {
+    case kIsacWideband:
+      {
+        bwest_str->send_bw_avg       = INIT_BN_EST_WB;
+        break;
+      }
+    case kIsacSuperWideband:
+      {
+        bwest_str->send_bw_avg       = INIT_BN_EST_SWB;
+        break;
+      }
+  }
+
+  switch(decoderSampRate)
+  {
+    case kIsacWideband:
+      {
+        bwest_str->prev_frame_length = INIT_FRAME_LEN_WB;
+        bwest_str->rec_bw_inv        = 1.0f /
+            (INIT_BN_EST_WB + INIT_HDR_RATE_WB);
+        bwest_str->rec_bw            = (int32_t)INIT_BN_EST_WB;
+        bwest_str->rec_bw_avg_Q      = INIT_BN_EST_WB;
+        bwest_str->rec_bw_avg        = INIT_BN_EST_WB + INIT_HDR_RATE_WB;
+        bwest_str->rec_header_rate   = INIT_HDR_RATE_WB;
+        break;
+      }
+    case kIsacSuperWideband:
+      {
+        bwest_str->prev_frame_length = INIT_FRAME_LEN_SWB;
+        bwest_str->rec_bw_inv        = 1.0f /
+            (INIT_BN_EST_SWB + INIT_HDR_RATE_SWB);
+        bwest_str->rec_bw            = (int32_t)INIT_BN_EST_SWB;
+        bwest_str->rec_bw_avg_Q      = INIT_BN_EST_SWB;
+        bwest_str->rec_bw_avg        = INIT_BN_EST_SWB + INIT_HDR_RATE_SWB;
+        bwest_str->rec_header_rate   = INIT_HDR_RATE_SWB;
+        break;
+      }
+  }
+
+  bwest_str->prev_rec_rtp_number       = 0;
+  bwest_str->prev_rec_arr_ts           = 0;
+  bwest_str->prev_rec_send_ts          = 0;
+  bwest_str->prev_rec_rtp_rate         = 1.0f;
+  bwest_str->last_update_ts            = 0;
+  bwest_str->last_reduction_ts         = 0;
+  bwest_str->count_tot_updates_rec     = -9;
+  bwest_str->rec_jitter                = 10.0f;
+  bwest_str->rec_jitter_short_term     = 0.0f;
+  bwest_str->rec_jitter_short_term_abs = 5.0f;
+  bwest_str->rec_max_delay             = 10.0f;
+  bwest_str->rec_max_delay_avg_Q       = 10.0f;
+  bwest_str->num_pkts_rec              = 0;
+
+  bwest_str->send_max_delay_avg        = 10.0f;
+
+  bwest_str->hsn_detect_rec = 0;
+
+  bwest_str->num_consec_rec_pkts_over_30k = 0;
+
+  bwest_str->hsn_detect_snd = 0;
+
+  bwest_str->num_consec_snt_pkts_over_30k = 0;
+
+  bwest_str->in_wait_period = 0;
+
+  bwest_str->change_to_WB = 0;
+
+  bwest_str->numConsecLatePkts = 0;
+  bwest_str->consecLatency = 0;
+  bwest_str->inWaitLatePkts = 0;
+  bwest_str->senderTimestamp = 0;
+  bwest_str->receiverTimestamp = 0;
+
+  bwest_str->external_bw_info.in_use = 0;
+
+  return 0;
+}
+
+/* This function updates both bottle neck rates                                                      */
+/* Parameters:                                                                                       */
+/* rtp_number    - value from RTP packet, from NetEq                                                 */
+/* frame length  - length of signal frame in ms, from iSAC decoder                                   */
+/* send_ts       - value in RTP header giving send time in samples                                     */
+/* arr_ts        - value given by timeGetTime() time of arrival in samples of packet from NetEq      */
+/* pksize        - size of packet in bytes, from NetEq                                               */
+/* Index         - integer (range 0...23) indicating bottle neck & jitter as estimated by other side */
+/* returns 0 if everything went fine, -1 otherwise                                                   */
+int16_t WebRtcIsac_UpdateBandwidthEstimator(
+    BwEstimatorstr* bwest_str,
+    const uint16_t rtp_number,
+    const int32_t frame_length,
+    const uint32_t send_ts,
+    const uint32_t arr_ts,
+    const size_t pksize
+    /*,    const uint16_t Index*/)
+{
+  float weight = 0.0f;
+  float curr_bw_inv = 0.0f;
+  float rec_rtp_rate;
+  float t_diff_proj;
+  float arr_ts_diff;
+  float send_ts_diff;
+  float arr_time_noise;
+  float arr_time_noise_abs;
+
+  float delay_correction_factor = 1;
+  float late_diff = 0.0f;
+  int immediate_set = 0;
+  int num_pkts_expected;
+
+  assert(!bwest_str->external_bw_info.in_use);
+
+  // We have to adjust the header-rate if the first packet has a
+  // frame-size different than the initialized value.
+  if ( frame_length != bwest_str->prev_frame_length )
+  {
+    bwest_str->rec_header_rate = (float)HEADER_SIZE * 8.0f *
+        1000.0f / (float)frame_length;     /* bits/s */
+  }
+
+  /* UPDATE ESTIMATES ON THIS SIDE */
+  /* compute far-side transmission rate */
+  rec_rtp_rate = ((float)pksize * 8.0f * 1000.0f / (float)frame_length) +
+      bwest_str->rec_header_rate;
+  // rec_rtp_rate packet bits/s + header bits/s
+
+  /* check for timer wrap-around */
+  if (arr_ts < bwest_str->prev_rec_arr_ts)
+  {
+    bwest_str->prev_rec_arr_ts   = arr_ts;
+    bwest_str->last_update_ts    = arr_ts;
+    bwest_str->last_reduction_ts = arr_ts + 3*FS;
+    bwest_str->num_pkts_rec      = 0;
+
+    /* store frame length */
+    bwest_str->prev_frame_length = frame_length;
+
+    /* store far-side transmission rate */
+    bwest_str->prev_rec_rtp_rate = rec_rtp_rate;
+
+    /* store far-side RTP time stamp */
+    bwest_str->prev_rec_rtp_number = rtp_number;
+
+    return 0;
+  }
+
+  bwest_str->num_pkts_rec++;
+
+  /* check that it's not one of the first 9 packets */
+  if ( bwest_str->count_tot_updates_rec > 0 )
+  {
+    if(bwest_str->in_wait_period > 0 )
+    {
+      bwest_str->in_wait_period--;
+    }
+
+    bwest_str->inWaitLatePkts -= ((bwest_str->inWaitLatePkts > 0)? 1:0);
+    send_ts_diff = (float)(send_ts - bwest_str->prev_rec_send_ts);
+
+    if (send_ts_diff <= (16 * frame_length)*2)
+      //doesn't allow for a dropped packet, not sure necessary to be
+      // that strict -DH
+    {
+      /* if not been updated for a long time, reduce the BN estimate */
+      if((uint32_t)(arr_ts - bwest_str->last_update_ts) *
+         1000.0f / FS > 3000)
+      {
+        //how many frames should have been received since the last
+        // update if too many have been dropped or there have been
+        // big delays won't allow this reduction may no longer need
+        // the send_ts_diff here
+        num_pkts_expected = (int)(((float)(arr_ts -
+                                           bwest_str->last_update_ts) * 1000.0f /(float) FS) /
+                                  (float)frame_length);
+
+        if(((float)bwest_str->num_pkts_rec/(float)num_pkts_expected) >
+           0.9)
+        {
+          float inv_bitrate = (float) pow( 0.99995,
+                                           (double)((uint32_t)(arr_ts -
+                                                                     bwest_str->last_reduction_ts)*1000.0f/FS) );
+
+          if ( inv_bitrate )
+          {
+            bwest_str->rec_bw_inv /= inv_bitrate;
+
+            //precautionary, likely never necessary
+            if (bwest_str->hsn_detect_snd &&
+                bwest_str->hsn_detect_rec)
+            {
+              if (bwest_str->rec_bw_inv > 0.000066f)
+              {
+                bwest_str->rec_bw_inv = 0.000066f;
+              }
+            }
+          }
+          else
+          {
+            bwest_str->rec_bw_inv = 1.0f /
+                (INIT_BN_EST_WB + INIT_HDR_RATE_WB);
+          }
+          /* reset time-since-update counter */
+          bwest_str->last_reduction_ts = arr_ts;
+        }
+        else
+          //reset here?
+        {
+          bwest_str->last_reduction_ts = arr_ts + 3*FS;
+          bwest_str->last_update_ts = arr_ts;
+          bwest_str->num_pkts_rec = 0;
+        }
+      }
+    }
+    else
+    {
+      bwest_str->last_reduction_ts = arr_ts + 3*FS;
+      bwest_str->last_update_ts = arr_ts;
+      bwest_str->num_pkts_rec = 0;
+    }
+
+
+    /* temporarily speed up adaptation if frame length has changed */
+    if ( frame_length != bwest_str->prev_frame_length )
+    {
+      bwest_str->count_tot_updates_rec = 10;
+      bwest_str->rec_header_rate = (float)HEADER_SIZE * 8.0f *
+          1000.0f / (float)frame_length;     /* bits/s */
+
+      bwest_str->rec_bw_inv = 1.0f /((float)bwest_str->rec_bw +
+                                     bwest_str->rec_header_rate);
+    }
+
+    ////////////////////////
+    arr_ts_diff = (float)(arr_ts - bwest_str->prev_rec_arr_ts);
+
+    if (send_ts_diff > 0 )
+    {
+      late_diff = arr_ts_diff - send_ts_diff;
+    }
+    else
+    {
+      late_diff = arr_ts_diff - (float)(16 * frame_length);
+    }
+
+    if((late_diff > 0) && !bwest_str->inWaitLatePkts)
+    {
+      bwest_str->numConsecLatePkts++;
+      bwest_str->consecLatency += late_diff;
+    }
+    else
+    {
+      bwest_str->numConsecLatePkts = 0;
+      bwest_str->consecLatency = 0;
+    }
+    if(bwest_str->numConsecLatePkts > 50)
+    {
+      float latencyMs = bwest_str->consecLatency/(FS/1000);
+      float averageLatencyMs = latencyMs / bwest_str->numConsecLatePkts;
+      delay_correction_factor = frame_length / (frame_length + averageLatencyMs);
+      immediate_set = 1;
+      bwest_str->inWaitLatePkts = (int16_t)((bwest_str->consecLatency/(FS/1000)) / 30);// + 150;
+      bwest_str->start_wait_period = arr_ts;
+    }
+    ///////////////////////////////////////////////
+
+
+
+    /*   update only if previous packet was not lost */
+    if ( rtp_number == bwest_str->prev_rec_rtp_number + 1 )
+    {
+
+
+      if (!(bwest_str->hsn_detect_snd && bwest_str->hsn_detect_rec))
+      {
+        if ((arr_ts_diff > (float)(16 * frame_length)))
+        {
+          //1/2 second
+          if ((late_diff > 8000.0f) && !bwest_str->in_wait_period)
+          {
+            delay_correction_factor = 0.7f;
+            bwest_str->in_wait_period = 55;
+            bwest_str->start_wait_period = arr_ts;
+            immediate_set = 1;
+          }
+          //320 ms
+          else if (late_diff > 5120.0f && !bwest_str->in_wait_period)
+          {
+            delay_correction_factor = 0.8f;
+            immediate_set = 1;
+            bwest_str->in_wait_period = 44;
+            bwest_str->start_wait_period = arr_ts;
+          }
+        }
+      }
+
+
+      if ((bwest_str->prev_rec_rtp_rate > bwest_str->rec_bw_avg) &&
+          (rec_rtp_rate > bwest_str->rec_bw_avg)                 &&
+          !bwest_str->in_wait_period)
+      {
+        /* test if still in initiation period and increment counter */
+        if (bwest_str->count_tot_updates_rec++ > 99)
+        {
+          /* constant weight after initiation part */
+          weight = 0.01f;
+        }
+        else
+        {
+          /* weight decreases with number of updates */
+          weight = 1.0f / (float) bwest_str->count_tot_updates_rec;
+        }
+        /* Bottle Neck Estimation */
+
+        /* limit outliers */
+        /* if more than 25 ms too much */
+        if (arr_ts_diff > frame_length * FS/1000 + 400.0f)
+        {
+          // in samples,  why 25ms??
+          arr_ts_diff = frame_length * FS/1000 + 400.0f;
+        }
+        if(arr_ts_diff < (frame_length * FS/1000) - 160.0f)
+        {
+          /* don't allow it to be less than frame rate - 10 ms */
+          arr_ts_diff = (float)frame_length * FS/1000 - 160.0f;
+        }
+
+        /* compute inverse receiving rate for last packet */
+        curr_bw_inv = arr_ts_diff / ((float)(pksize + HEADER_SIZE) *
+                                     8.0f * FS); // (180+35)*8*16000 = 27.5 Mbit....
+
+
+        if(curr_bw_inv <
+           (1.0f / (MAX_ISAC_BW + bwest_str->rec_header_rate)))
+        {
+          // don't allow inv rate to be larger than MAX
+          curr_bw_inv = (1.0f /
+                         (MAX_ISAC_BW + bwest_str->rec_header_rate));
+        }
+
+        /* update bottle neck rate estimate */
+        bwest_str->rec_bw_inv = weight * curr_bw_inv +
+            (1.0f - weight) * bwest_str->rec_bw_inv;
+
+        /* reset time-since-update counter */
+        bwest_str->last_update_ts    = arr_ts;
+        bwest_str->last_reduction_ts = arr_ts + 3 * FS;
+        bwest_str->num_pkts_rec = 0;
+
+        /* Jitter Estimation */
+        /* projected difference between arrival times */
+        t_diff_proj = ((float)(pksize + HEADER_SIZE) * 8.0f *
+                       1000.0f) / bwest_str->rec_bw_avg;
+
+
+        // difference between projected and actual
+        //   arrival time differences
+        arr_time_noise = (float)(arr_ts_diff*1000.0f/FS) -
+            t_diff_proj;
+        arr_time_noise_abs = (float) fabs( arr_time_noise );
+
+        /* long term averaged absolute jitter */
+        bwest_str->rec_jitter = weight * arr_time_noise_abs +
+            (1.0f - weight) * bwest_str->rec_jitter;
+        if (bwest_str->rec_jitter > 10.0f)
+        {
+          bwest_str->rec_jitter = 10.0f;
+        }
+        /* short term averaged absolute jitter */
+        bwest_str->rec_jitter_short_term_abs = 0.05f *
+            arr_time_noise_abs + 0.95f *
+            bwest_str->rec_jitter_short_term_abs;
+
+        /* short term averaged jitter */
+        bwest_str->rec_jitter_short_term = 0.05f * arr_time_noise +
+            0.95f * bwest_str->rec_jitter_short_term;
+      }
+    }
+  }
+  else
+  {
+    // reset time-since-update counter when
+    // receiving the first 9 packets
+    bwest_str->last_update_ts    = arr_ts;
+    bwest_str->last_reduction_ts = arr_ts + 3*FS;
+    bwest_str->num_pkts_rec = 0;
+
+    bwest_str->count_tot_updates_rec++;
+  }
+
+  /* limit minimum bottle neck rate */
+  if (bwest_str->rec_bw_inv > 1.0f / ((float)MIN_ISAC_BW +
+                                      bwest_str->rec_header_rate))
+  {
+    bwest_str->rec_bw_inv = 1.0f / ((float)MIN_ISAC_BW +
+                                    bwest_str->rec_header_rate);
+  }
+
+  // limit maximum bitrate
+  if (bwest_str->rec_bw_inv < 1.0f / ((float)MAX_ISAC_BW +
+                                      bwest_str->rec_header_rate))
+  {
+    bwest_str->rec_bw_inv = 1.0f / ((float)MAX_ISAC_BW +
+                                    bwest_str->rec_header_rate);
+  }
+
+  /* store frame length */
+  bwest_str->prev_frame_length = frame_length;
+
+  /* store far-side transmission rate */
+  bwest_str->prev_rec_rtp_rate = rec_rtp_rate;
+
+  /* store far-side RTP time stamp */
+  bwest_str->prev_rec_rtp_number = rtp_number;
+
+  // Replace bwest_str->rec_max_delay by the new
+  // value (atomic operation)
+  bwest_str->rec_max_delay = 3.0f * bwest_str->rec_jitter;
+
+  /* store send and arrival time stamp */
+  bwest_str->prev_rec_arr_ts = arr_ts ;
+  bwest_str->prev_rec_send_ts = send_ts;
+
+  /* Replace bwest_str->rec_bw by the new value (atomic operation) */
+  bwest_str->rec_bw = (int32_t)(1.0f / bwest_str->rec_bw_inv -
+                                      bwest_str->rec_header_rate);
+
+  if (immediate_set)
+  {
+    bwest_str->rec_bw = (int32_t) (delay_correction_factor *
+                                         (float) bwest_str->rec_bw);
+
+    if (bwest_str->rec_bw < (int32_t) MIN_ISAC_BW)
+    {
+      bwest_str->rec_bw = (int32_t) MIN_ISAC_BW;
+    }
+
+    bwest_str->rec_bw_avg = bwest_str->rec_bw +
+        bwest_str->rec_header_rate;
+
+    bwest_str->rec_bw_avg_Q = (float) bwest_str->rec_bw;
+
+    bwest_str->rec_jitter_short_term = 0.0f;
+
+    bwest_str->rec_bw_inv = 1.0f / (bwest_str->rec_bw +
+                                    bwest_str->rec_header_rate);
+
+    bwest_str->count_tot_updates_rec = 1;
+
+    immediate_set = 0;
+    bwest_str->consecLatency = 0;
+    bwest_str->numConsecLatePkts = 0;
+  }
+
+  return 0;
+}
+
+
+/* This function updates the send bottle neck rate                                                   */
+/* Index         - integer (range 0...23) indicating bottle neck & jitter as estimated by other side */
+/* returns 0 if everything went fine, -1 otherwise                                                   */
+int16_t WebRtcIsac_UpdateUplinkBwImpl(
+    BwEstimatorstr*           bwest_str,
+    int16_t               index,
+    enum IsacSamplingRate encoderSamplingFreq)
+{
+  assert(!bwest_str->external_bw_info.in_use);
+
+  if((index < 0) || (index > 23))
+  {
+    return -ISAC_RANGE_ERROR_BW_ESTIMATOR;
+  }
+
+  /* UPDATE ESTIMATES FROM OTHER SIDE */
+  if(encoderSamplingFreq == kIsacWideband)
+  {
+    if(index > 11)
+    {
+      index -= 12;   
+      /* compute the jitter estimate as decoded on the other side */
+      bwest_str->send_max_delay_avg = 0.9f * bwest_str->send_max_delay_avg +
+          0.1f * (float)MAX_ISAC_MD;
+    }
+    else
+    {
+      /* compute the jitter estimate as decoded on the other side */
+      bwest_str->send_max_delay_avg = 0.9f * bwest_str->send_max_delay_avg +
+          0.1f * (float)MIN_ISAC_MD;
+    }
+
+    /* compute the BN estimate as decoded on the other side */
+    bwest_str->send_bw_avg = 0.9f * bwest_str->send_bw_avg +
+        0.1f * kQRateTableWb[index];
+  }
+  else
+  {
+    /* compute the BN estimate as decoded on the other side */
+    bwest_str->send_bw_avg = 0.9f * bwest_str->send_bw_avg +
+        0.1f * kQRateTableSwb[index];
+  }
+
+  if (bwest_str->send_bw_avg > (float) 28000 && !bwest_str->hsn_detect_snd)
+  {
+    bwest_str->num_consec_snt_pkts_over_30k++;
+
+    if (bwest_str->num_consec_snt_pkts_over_30k >= 66)
+    {
+      //approx 2 seconds with 30ms frames
+      bwest_str->hsn_detect_snd = 1;
+    }
+  }
+  else if (!bwest_str->hsn_detect_snd)
+  {
+    bwest_str->num_consec_snt_pkts_over_30k = 0;
+  }
+  return 0;
+}
+
+// called when there is upper-band bit-stream to update jitter
+// statistics.
+int16_t WebRtcIsac_UpdateUplinkJitter(
+    BwEstimatorstr*              bwest_str,
+    int32_t                  index)
+{
+  assert(!bwest_str->external_bw_info.in_use);
+
+  if((index < 0) || (index > 23))
+  {
+    return -ISAC_RANGE_ERROR_BW_ESTIMATOR;
+  }
+
+  if(index > 0)
+  {
+    /* compute the jitter estimate as decoded on the other side */
+    bwest_str->send_max_delay_avg = 0.9f * bwest_str->send_max_delay_avg +
+        0.1f * (float)MAX_ISAC_MD;
+  }
+  else
+  {
+    /* compute the jitter estimate as decoded on the other side */
+    bwest_str->send_max_delay_avg = 0.9f * bwest_str->send_max_delay_avg +
+        0.1f * (float)MIN_ISAC_MD;
+  }
+
+  return 0;
+}
+
+
+
+// Returns the bandwidth/jitter estimation code (integer 0...23)
+// to put in the sending iSAC payload
+void
+WebRtcIsac_GetDownlinkBwJitIndexImpl(
+    BwEstimatorstr*           bwest_str,
+    int16_t*              bottleneckIndex,
+    int16_t*              jitterInfo,
+    enum IsacSamplingRate decoderSamplingFreq)
+{
+  float MaxDelay;
+  //uint16_t MaxDelayBit;
+
+  float rate;
+  float r;
+  float e1, e2;
+  const float weight = 0.1f;
+  const float* ptrQuantizationTable;
+  int16_t addJitterInfo;
+  int16_t minInd;
+  int16_t maxInd;
+  int16_t midInd;
+
+  if (bwest_str->external_bw_info.in_use) {
+    *bottleneckIndex = bwest_str->external_bw_info.bottleneck_idx;
+    *jitterInfo = bwest_str->external_bw_info.jitter_info;
+    return;
+  }
+
+  /* Get Max Delay Bit */
+  /* get unquantized max delay */
+  MaxDelay = (float)WebRtcIsac_GetDownlinkMaxDelay(bwest_str);
+
+  if ( ((1.f - weight) * bwest_str->rec_max_delay_avg_Q + weight *
+        MAX_ISAC_MD - MaxDelay) > (MaxDelay - (1.f-weight) *
+                                   bwest_str->rec_max_delay_avg_Q - weight * MIN_ISAC_MD) )
+  {
+    jitterInfo[0] = 0;
+    /* update quantized average */
+    bwest_str->rec_max_delay_avg_Q =
+        (1.f - weight) * bwest_str->rec_max_delay_avg_Q + weight *
+        (float)MIN_ISAC_MD;
+  }
+  else
+  {
+    jitterInfo[0] = 1;
+    /* update quantized average */
+    bwest_str->rec_max_delay_avg_Q =
+        (1.f-weight) * bwest_str->rec_max_delay_avg_Q + weight *
+        (float)MAX_ISAC_MD;
+  }
+
+  // Get unquantized rate.
+  rate = (float)WebRtcIsac_GetDownlinkBandwidth(bwest_str);
+
+  /* Get Rate Index */
+  if(decoderSamplingFreq == kIsacWideband)
+  {
+    ptrQuantizationTable = kQRateTableWb;
+    addJitterInfo = 1;
+    maxInd = 11;
+  }
+  else
+  {
+    ptrQuantizationTable = kQRateTableSwb;
+    addJitterInfo = 0;
+    maxInd = 23;
+  }
+
+  minInd = 0;
+  while(maxInd > minInd + 1)
+  {
+    midInd = (maxInd + minInd) >> 1;
+    if(rate > ptrQuantizationTable[midInd])
+    {
+      minInd = midInd;
+    }
+    else
+    {
+      maxInd = midInd;
+    }
+  }
+  // Chose the index which gives results an average which is closest
+  // to rate
+  r = (1 - weight) * bwest_str->rec_bw_avg_Q - rate;
+  e1 = weight * ptrQuantizationTable[minInd] + r;
+  e2 = weight * ptrQuantizationTable[maxInd] + r;
+  e1 = (e1 > 0)? e1:-e1;
+  e2 = (e2 > 0)? e2:-e2;
+  if(e1 < e2)
+  {
+    bottleneckIndex[0] = minInd;
+  }
+  else
+  {
+    bottleneckIndex[0] = maxInd;
+  }
+
+  bwest_str->rec_bw_avg_Q = (1 - weight) * bwest_str->rec_bw_avg_Q +
+      weight * ptrQuantizationTable[bottleneckIndex[0]];
+  bottleneckIndex[0] += jitterInfo[0] * 12 * addJitterInfo;
+
+  bwest_str->rec_bw_avg = (1 - weight) * bwest_str->rec_bw_avg + weight *
+      (rate + bwest_str->rec_header_rate);
+}
+
+
+
+/* get the bottle neck rate from far side to here, as estimated on this side */
+int32_t WebRtcIsac_GetDownlinkBandwidth( const BwEstimatorstr *bwest_str)
+{
+  int32_t  rec_bw;
+  float   jitter_sign;
+  float   bw_adjust;
+
+  assert(!bwest_str->external_bw_info.in_use);
+
+  /* create a value between -1.0 and 1.0 indicating "average sign" of jitter */
+  jitter_sign = bwest_str->rec_jitter_short_term /
+      bwest_str->rec_jitter_short_term_abs;
+
+  /* adjust bw proportionally to negative average jitter sign */
+  bw_adjust = 1.0f - jitter_sign * (0.15f + 0.15f * jitter_sign * jitter_sign);
+
+  /* adjust Rate if jitter sign is mostly constant */
+  rec_bw = (int32_t)(bwest_str->rec_bw * bw_adjust);
+
+  /* limit range of bottle neck rate */
+  if (rec_bw < MIN_ISAC_BW)
+  {
+    rec_bw = MIN_ISAC_BW;
+  }
+  else if (rec_bw > MAX_ISAC_BW)
+  {
+    rec_bw = MAX_ISAC_BW;
+  }
+  return rec_bw;
+}
+
+/* Returns the max delay (in ms) */
+int32_t
+WebRtcIsac_GetDownlinkMaxDelay(const BwEstimatorstr *bwest_str)
+{
+  int32_t rec_max_delay;
+
+  assert(!bwest_str->external_bw_info.in_use);
+
+  rec_max_delay = (int32_t)(bwest_str->rec_max_delay);
+
+  /* limit range of jitter estimate */
+  if (rec_max_delay < MIN_ISAC_MD)
+  {
+    rec_max_delay = MIN_ISAC_MD;
+  }
+  else if (rec_max_delay > MAX_ISAC_MD)
+  {
+    rec_max_delay = MAX_ISAC_MD;
+  }
+  return rec_max_delay;
+}
+
+/* Clamp val to the closed interval [min,max]. */
+static int32_t clamp(int32_t val, int32_t min, int32_t max) {
+  assert(min <= max);
+  return val < min ? min : (val > max ? max : val);
+}
+
+int32_t WebRtcIsac_GetUplinkBandwidth(const BwEstimatorstr* bwest_str) {
+  return bwest_str->external_bw_info.in_use
+             ? bwest_str->external_bw_info.send_bw_avg
+             : clamp(bwest_str->send_bw_avg, MIN_ISAC_BW, MAX_ISAC_BW);
+}
+
+int32_t WebRtcIsac_GetUplinkMaxDelay(const BwEstimatorstr* bwest_str) {
+  return bwest_str->external_bw_info.in_use
+             ? bwest_str->external_bw_info.send_max_delay_avg
+             : clamp(bwest_str->send_max_delay_avg, MIN_ISAC_MD, MAX_ISAC_MD);
+}
+
+void WebRtcIsacBw_GetBandwidthInfo(BwEstimatorstr* bwest_str,
+                                   enum IsacSamplingRate decoder_sample_rate_hz,
+                                   IsacBandwidthInfo* bwinfo) {
+  assert(!bwest_str->external_bw_info.in_use);
+  bwinfo->in_use = 1;
+  bwinfo->send_bw_avg = WebRtcIsac_GetUplinkBandwidth(bwest_str);
+  bwinfo->send_max_delay_avg = WebRtcIsac_GetUplinkMaxDelay(bwest_str);
+  WebRtcIsac_GetDownlinkBwJitIndexImpl(bwest_str, &bwinfo->bottleneck_idx,
+                                       &bwinfo->jitter_info,
+                                       decoder_sample_rate_hz);
+}
+
+void WebRtcIsacBw_SetBandwidthInfo(BwEstimatorstr* bwest_str,
+                                   const IsacBandwidthInfo* bwinfo) {
+  memcpy(&bwest_str->external_bw_info, bwinfo,
+         sizeof bwest_str->external_bw_info);
+}
+
+/*
+ * update long-term average bitrate and amount of data in buffer
+ * returns minimum payload size (bytes)
+ */
+int WebRtcIsac_GetMinBytes(
+    RateModel*         State,
+    int                StreamSize,    /* bytes in bitstream */
+    const int          FrameSamples,  /* samples per frame */
+    const double       BottleNeck,    /* bottle neck rate; excl headers (bps) */
+    const double       DelayBuildUp,  /* max delay from bottleneck buffering (ms) */
+    enum ISACBandwidth bandwidth
+    /*,int16_t        frequentLargePackets*/)
+{
+  double MinRate = 0.0;
+  int    MinBytes;
+  double TransmissionTime;
+  int    burstInterval = BURST_INTERVAL;
+
+  // first 10 packets @ low rate, then INIT_BURST_LEN packets @
+  // fixed rate of INIT_RATE bps
+  if (State->InitCounter > 0)
+  {
+    if (State->InitCounter-- <= INIT_BURST_LEN)
+    {
+      if(bandwidth == isac8kHz)
+      {
+        MinRate = INIT_RATE_WB;
+      }
+      else
+      {
+        MinRate = INIT_RATE_SWB;
+      }
+    }
+    else
+    {
+      MinRate = 0;
+    }
+  }
+  else
+  {
+    /* handle burst */
+    if (State->BurstCounter)
+    {
+      if (State->StillBuffered < (1.0 - 1.0/BURST_LEN) * DelayBuildUp)
+      {
+        /* max bps derived from BottleNeck and DelayBuildUp values */
+        MinRate = (1.0 + (FS/1000) * DelayBuildUp /
+                   (double)(BURST_LEN * FrameSamples)) * BottleNeck;
+      }
+      else
+      {
+        // max bps derived from StillBuffered and DelayBuildUp
+        // values
+        MinRate = (1.0 + (FS/1000) * (DelayBuildUp -
+                                      State->StillBuffered) / (double)FrameSamples) * BottleNeck;
+        if (MinRate < 1.04 * BottleNeck)
+        {
+          MinRate = 1.04 * BottleNeck;
+        }
+      }
+      State->BurstCounter--;
+    }
+  }
+
+
+  /* convert rate from bits/second to bytes/packet */
+  MinBytes = (int) (MinRate * FrameSamples / (8.0 * FS));
+
+  /* StreamSize will be adjusted if less than MinBytes */
+  if (StreamSize < MinBytes)
+  {
+    StreamSize = MinBytes;
+  }
+
+  /* keep track of when bottle neck was last exceeded by at least 1% */
+  if (StreamSize * 8.0 * FS / FrameSamples > 1.01 * BottleNeck) {
+    if (State->PrevExceed) {
+      /* bottle_neck exceded twice in a row, decrease ExceedAgo */
+      State->ExceedAgo -= /*BURST_INTERVAL*/ burstInterval / (BURST_LEN - 1);
+      if (State->ExceedAgo < 0)
+        State->ExceedAgo = 0;
+    }
+    else
+    {
+      State->ExceedAgo += (FrameSamples * 1000) / FS; /* ms */
+      State->PrevExceed = 1;
+    }
+  }
+  else
+  {
+    State->PrevExceed = 0;
+    State->ExceedAgo += (FrameSamples * 1000) / FS;     /* ms */
+  }
+
+  /* set burst flag if bottle neck not exceeded for long time */
+  if ((State->ExceedAgo > burstInterval) &&
+      (State->BurstCounter == 0))
+  {
+    if (State->PrevExceed)
+    {
+      State->BurstCounter = BURST_LEN - 1;
+    }
+    else
+    {
+      State->BurstCounter = BURST_LEN;
+    }
+  }
+
+
+  /* Update buffer delay */
+  TransmissionTime = StreamSize * 8.0 * 1000.0 / BottleNeck;  /* ms */
+  State->StillBuffered += TransmissionTime;
+  State->StillBuffered -= (FrameSamples * 1000) / FS;     /* ms */
+  if (State->StillBuffered < 0.0)
+  {
+    State->StillBuffered = 0.0;
+  }
+
+  return MinBytes;
+}
+
+
+/*
+ * update long-term average bitrate and amount of data in buffer
+ */
+void WebRtcIsac_UpdateRateModel(
+    RateModel *State,
+    int StreamSize,                    /* bytes in bitstream */
+    const int FrameSamples,            /* samples per frame */
+    const double BottleNeck)        /* bottle neck rate; excl headers (bps) */
+{
+  double TransmissionTime;
+
+  /* avoid the initial "high-rate" burst */
+  State->InitCounter = 0;
+
+  /* Update buffer delay */
+  TransmissionTime = StreamSize * 8.0 * 1000.0 / BottleNeck;  /* ms */
+  State->StillBuffered += TransmissionTime;
+  State->StillBuffered -= (FrameSamples * 1000) / FS;     /* ms */
+  if (State->StillBuffered < 0.0)
+    State->StillBuffered = 0.0;
+
+}
+
+
+void WebRtcIsac_InitRateModel(
+    RateModel *State)
+{
+  State->PrevExceed      = 0;                        /* boolean */
+  State->ExceedAgo       = 0;                        /* ms */
+  State->BurstCounter    = 0;                        /* packets */
+  State->InitCounter     = INIT_BURST_LEN + 10;    /* packets */
+  State->StillBuffered   = 1.0;                    /* ms */
+}
+
+int WebRtcIsac_GetNewFrameLength(
+    double bottle_neck,
+    int    current_framesamples)
+{
+  int new_framesamples;
+
+  const int Thld_20_30 = 20000;
+
+  //const int Thld_30_20 = 30000;
+  const int Thld_30_20 = 1000000;   // disable 20 ms frames
+
+  const int Thld_30_60 = 18000;
+  //const int Thld_30_60 = 0;      // disable 60 ms frames
+
+  const int Thld_60_30 = 27000;
+
+
+  new_framesamples = current_framesamples;
+
+  /* find new framelength */
+  switch(current_framesamples) {
+    case 320:
+      if (bottle_neck < Thld_20_30)
+        new_framesamples = 480;
+      break;
+    case 480:
+      if (bottle_neck < Thld_30_60)
+        new_framesamples = 960;
+      else if (bottle_neck > Thld_30_20)
+        new_framesamples = 320;
+      break;
+    case 960:
+      if (bottle_neck >= Thld_60_30)
+        new_framesamples = 480;
+      break;
+  }
+
+  return new_framesamples;
+}
+
+double WebRtcIsac_GetSnr(
+    double bottle_neck,
+    int    framesamples)
+{
+  double s2nr;
+
+  const double a_20 = -30.0;
+  const double b_20 = 0.8;
+  const double c_20 = 0.0;
+
+  const double a_30 = -23.0;
+  const double b_30 = 0.48;
+  const double c_30 = 0.0;
+
+  const double a_60 = -23.0;
+  const double b_60 = 0.53;
+  const double c_60 = 0.0;
+
+
+  /* find new SNR value */
+  switch(framesamples) {
+    case 320:
+      s2nr = a_20 + b_20 * bottle_neck * 0.001 + c_20 * bottle_neck *
+          bottle_neck * 0.000001;
+      break;
+    case 480:
+      s2nr = a_30 + b_30 * bottle_neck * 0.001 + c_30 * bottle_neck *
+          bottle_neck * 0.000001;
+      break;
+    case 960:
+      s2nr = a_60 + b_60 * bottle_neck * 0.001 + c_60 * bottle_neck *
+          bottle_neck * 0.000001;
+      break;
+    default:
+      s2nr = 0;
+  }
+
+  return s2nr;
+
+}
diff --git a/webrtc/modules/audio_coding/codecs/isac/main/source/bandwidth_estimator.h b/webrtc/modules/audio_coding/codecs/isac/main/source/bandwidth_estimator.h
new file mode 100644
index 0000000..0704337
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/main/source/bandwidth_estimator.h
@@ -0,0 +1,184 @@
+/*
+ *  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.
+ */
+
+/*
+ * bandwidth_estimator.h
+ *
+ * This header file contains the API for the Bandwidth Estimator
+ * designed for iSAC.
+ *
+ */
+
+#ifndef WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_BANDWIDTH_ESTIMATOR_H_
+#define WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_BANDWIDTH_ESTIMATOR_H_
+
+#include "structs.h"
+#include "settings.h"
+
+
+#define MIN_ISAC_BW     10000
+#define MIN_ISAC_BW_LB  10000
+#define MIN_ISAC_BW_UB  25000
+
+#define MAX_ISAC_BW     56000
+#define MAX_ISAC_BW_UB  32000
+#define MAX_ISAC_BW_LB  32000
+
+#define MIN_ISAC_MD     5
+#define MAX_ISAC_MD     25
+
+// assumed header size, in bytes; we don't know the exact number
+// (header compression may be used)
+#define HEADER_SIZE        35
+
+// Initial Frame-Size, in ms, for Wideband & Super-Wideband Mode
+#define INIT_FRAME_LEN_WB  60
+#define INIT_FRAME_LEN_SWB 30
+
+// Initial Bottleneck Estimate, in bits/sec, for
+// Wideband & Super-wideband mode
+#define INIT_BN_EST_WB     20e3f
+#define INIT_BN_EST_SWB    56e3f
+
+// Initial Header rate (header rate depends on frame-size),
+// in bits/sec, for Wideband & Super-Wideband mode.
+#define INIT_HDR_RATE_WB                                                \
+  ((float)HEADER_SIZE * 8.0f * 1000.0f / (float)INIT_FRAME_LEN_WB)
+#define INIT_HDR_RATE_SWB                                               \
+  ((float)HEADER_SIZE * 8.0f * 1000.0f / (float)INIT_FRAME_LEN_SWB)
+
+// number of packets in a row for a high rate burst
+#define BURST_LEN       3
+
+// ms, max time between two full bursts
+#define BURST_INTERVAL  500
+
+// number of packets in a row for initial high rate burst
+#define INIT_BURST_LEN  5
+
+// bits/s, rate for the first BURST_LEN packets
+#define INIT_RATE_WB       INIT_BN_EST_WB
+#define INIT_RATE_SWB      INIT_BN_EST_SWB
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+  /* This function initializes the struct                    */
+  /* to be called before using the struct for anything else  */
+  /* returns 0 if everything went fine, -1 otherwise         */
+  int32_t WebRtcIsac_InitBandwidthEstimator(
+      BwEstimatorstr*           bwest_str,
+      enum IsacSamplingRate encoderSampRate,
+      enum IsacSamplingRate decoderSampRate);
+
+  /* This function updates the receiving estimate                                                      */
+  /* Parameters:                                                                                       */
+  /* rtp_number    - value from RTP packet, from NetEq                                                 */
+  /* frame length  - length of signal frame in ms, from iSAC decoder                                   */
+  /* send_ts       - value in RTP header giving send time in samples                                   */
+  /* arr_ts        - value given by timeGetTime() time of arrival in samples of packet from NetEq      */
+  /* pksize        - size of packet in bytes, from NetEq                                               */
+  /* Index         - integer (range 0...23) indicating bottle neck & jitter as estimated by other side */
+  /* returns 0 if everything went fine, -1 otherwise                                                   */
+  int16_t WebRtcIsac_UpdateBandwidthEstimator(
+      BwEstimatorstr* bwest_str,
+      const uint16_t rtp_number,
+      const int32_t frame_length,
+      const uint32_t send_ts,
+      const uint32_t arr_ts,
+      const size_t pksize);
+
+  /* Update receiving estimates. Used when we only receive BWE index, no iSAC data packet. */
+  int16_t WebRtcIsac_UpdateUplinkBwImpl(
+      BwEstimatorstr*           bwest_str,
+      int16_t               Index,
+      enum IsacSamplingRate encoderSamplingFreq);
+
+  /* Returns the bandwidth/jitter estimation code (integer 0...23) to put in the sending iSAC payload */
+  void WebRtcIsac_GetDownlinkBwJitIndexImpl(
+      BwEstimatorstr* bwest_str,
+      int16_t* bottleneckIndex,
+      int16_t* jitterInfo,
+      enum IsacSamplingRate decoderSamplingFreq);
+
+  /* Returns the bandwidth estimation (in bps) */
+  int32_t WebRtcIsac_GetDownlinkBandwidth(
+      const BwEstimatorstr *bwest_str);
+
+  /* Returns the max delay (in ms) */
+  int32_t WebRtcIsac_GetDownlinkMaxDelay(
+      const BwEstimatorstr *bwest_str);
+
+  /* Returns the bandwidth that iSAC should send with in bps */
+  int32_t WebRtcIsac_GetUplinkBandwidth(const BwEstimatorstr* bwest_str);
+
+  /* Returns the max delay value from the other side in ms */
+  int32_t WebRtcIsac_GetUplinkMaxDelay(
+      const BwEstimatorstr *bwest_str);
+
+  /* Fills in an IsacExternalBandwidthInfo struct. */
+  void WebRtcIsacBw_GetBandwidthInfo(
+      BwEstimatorstr* bwest_str,
+      enum IsacSamplingRate decoder_sample_rate_hz,
+      IsacBandwidthInfo* bwinfo);
+
+  /* Uses the values from an IsacExternalBandwidthInfo struct. */
+  void WebRtcIsacBw_SetBandwidthInfo(BwEstimatorstr* bwest_str,
+                                     const IsacBandwidthInfo* bwinfo);
+
+  /*
+   * update amount of data in bottle neck buffer and burst handling
+   * returns minimum payload size (bytes)
+   */
+  int WebRtcIsac_GetMinBytes(
+      RateModel*         State,
+      int                StreamSize,    /* bytes in bitstream */
+      const int          FrameLen,      /* ms per frame */
+      const double       BottleNeck,    /* bottle neck rate; excl headers (bps) */
+      const double       DelayBuildUp,  /* max delay from bottleneck buffering (ms) */
+      enum ISACBandwidth bandwidth
+      /*,int16_t        frequentLargePackets*/);
+
+  /*
+   * update long-term average bitrate and amount of data in buffer
+   */
+  void WebRtcIsac_UpdateRateModel(
+      RateModel*   State,
+      int          StreamSize,                /* bytes in bitstream */
+      const int    FrameSamples,        /* samples per frame */
+      const double BottleNeck);       /* bottle neck rate; excl headers (bps) */
+
+
+  void WebRtcIsac_InitRateModel(
+      RateModel *State);
+
+  /* Returns the new framelength value (input argument: bottle_neck) */
+  int WebRtcIsac_GetNewFrameLength(
+      double bottle_neck,
+      int    current_framelength);
+
+  /* Returns the new SNR value (input argument: bottle_neck) */
+  double WebRtcIsac_GetSnr(
+      double bottle_neck,
+      int    new_framelength);
+
+
+  int16_t WebRtcIsac_UpdateUplinkJitter(
+      BwEstimatorstr*              bwest_str,
+      int32_t                  index);
+
+#if defined(__cplusplus)
+}
+#endif
+
+
+#endif /* WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_BANDWIDTH_ESTIMATOR_H_ */
diff --git a/webrtc/modules/audio_coding/codecs/isac/main/source/crc.c b/webrtc/modules/audio_coding/codecs/isac/main/source/crc.c
new file mode 100644
index 0000000..ebef595
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/main/source/crc.c
@@ -0,0 +1,110 @@
+/*
+ *  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.
+ */
+
+#include "crc.h"
+#include <stdlib.h>
+#include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
+
+#define POLYNOMIAL 0x04c11db7L
+
+
+static const uint32_t kCrcTable[256] = {
+  0,          0x4c11db7,  0x9823b6e,  0xd4326d9,  0x130476dc, 0x17c56b6b,
+  0x1a864db2, 0x1e475005, 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
+  0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, 0x4c11db70, 0x48d0c6c7,
+  0x4593e01e, 0x4152fda9, 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
+  0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3,
+  0x709f7b7a, 0x745e66cd, 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
+  0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 0xbe2b5b58, 0xbaea46ef,
+  0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
+  0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 0xc7361b4c, 0xc3f706fb,
+  0xceb42022, 0xca753d95, 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1,
+  0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 0x34867077, 0x30476dc0,
+  0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
+  0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 0x18aeb13,  0x54bf6a4,
+  0x808d07d,  0xcc9cdca,  0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde,
+  0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, 0x5e9f46bf, 0x5a5e5b08,
+  0x571d7dd1, 0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
+  0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b, 0xbb60adfc,
+  0xb6238b25, 0xb2e29692, 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6,
+  0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, 0xe0b41de7, 0xe4750050,
+  0xe9362689, 0xedf73b3e, 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
+  0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34,
+  0xdc3abded, 0xd8fba05a, 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637,
+  0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, 0x4f040d56, 0x4bc510e1,
+  0x46863638, 0x42472b8f, 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
+  0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5,
+  0x3f9b762c, 0x3b5a6b9b,  0x315d626, 0x7d4cb91,  0xa97ed48,  0xe56f0ff,
+  0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 0xf12f560e, 0xf5ee4bb9,
+  0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
+  0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 0xc423cd6a, 0xc0e2d0dd,
+  0xcda1f604, 0xc960ebb3, 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7,
+  0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 0x9b3660c6, 0x9ff77d71,
+  0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
+  0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 0x4e8ee645, 0x4a4ffbf2,
+  0x470cdd2b, 0x43cdc09c, 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8,
+  0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, 0x119b4be9, 0x155a565e,
+  0x18197087, 0x1cd86d30, 0x29f3d35,  0x65e2082,  0xb1d065b,  0xfdc1bec,
+  0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d, 0x2056cd3a,
+  0x2d15ebe3, 0x29d4f654, 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0,
+  0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, 0xe3a1cbc1, 0xe760d676,
+  0xea23f0af, 0xeee2ed18, 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
+  0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662,
+  0x933eb0bb, 0x97ffad0c, 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668,
+  0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
+};
+
+
+
+
+/****************************************************************************
+ * WebRtcIsac_GetCrc(...)
+ *
+ * This function returns a 32 bit CRC checksum of a bit stream
+ *
+ * Input:
+ *  - bitstream              : payload bitstream
+ *  - len_bitstream_in_bytes : number of 8-bit words in the bit stream
+ *
+ * Output:
+ *  - crc                    : checksum
+ *
+ * Return value              :  0 - Ok
+ *                             -1 - Error
+ */
+
+int WebRtcIsac_GetCrc(const int16_t* bitstream,
+                      int len_bitstream_in_bytes,
+                      uint32_t* crc)
+{
+  uint8_t* bitstream_ptr_uw8;
+  uint32_t crc_state;
+  int byte_cntr;
+  int crc_tbl_indx;
+
+  /* Sanity Check. */
+  if (bitstream == NULL) {
+    return -1;
+  }
+  /* cast to UWord8 pointer */
+  bitstream_ptr_uw8 = (uint8_t *)bitstream;
+
+  /* initialize */
+  crc_state = 0xFFFFFFFF;
+
+  for (byte_cntr = 0; byte_cntr < len_bitstream_in_bytes; byte_cntr++) {
+    crc_tbl_indx = (WEBRTC_SPL_RSHIFT_U32(crc_state, 24) ^
+                       bitstream_ptr_uw8[byte_cntr]) & 0xFF;
+    crc_state = (crc_state << 8) ^ kCrcTable[crc_tbl_indx];
+  }
+
+  *crc = ~crc_state;
+  return 0;
+}
diff --git a/webrtc/modules/audio_coding/codecs/isac/main/source/crc.h b/webrtc/modules/audio_coding/codecs/isac/main/source/crc.h
new file mode 100644
index 0000000..09583df
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/main/source/crc.h
@@ -0,0 +1,46 @@
+/*
+ *  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.
+ */
+
+/*
+ * crc.h
+ *
+ * Checksum functions
+ *
+ */
+
+#ifndef WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_CRC_H_
+#define WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_CRC_H_
+
+#include "webrtc/typedefs.h"
+
+/****************************************************************************
+ * WebRtcIsac_GetCrc(...)
+ *
+ * This function returns a 32 bit CRC checksum of a bit stream
+ *
+ * Input:
+ *  - encoded      : payload bit stream
+ *  - no_of_word8s : number of 8-bit words in the bit stream
+ *
+ * Output:
+ *  - crc          : checksum
+ *
+ * Return value    :  0 - Ok
+ *                   -1 - Error
+ */
+
+int WebRtcIsac_GetCrc(
+    const int16_t* encoded,
+    int no_of_word8s,
+    uint32_t* crc);
+
+
+
+#endif /* WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_CRC_H_ */
diff --git a/webrtc/modules/audio_coding/codecs/isac/main/source/decode.c b/webrtc/modules/audio_coding/codecs/isac/main/source/decode.c
new file mode 100644
index 0000000..e925efb
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/main/source/decode.c
@@ -0,0 +1,304 @@
+/*
+ *  Copyright (c) 2012 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.
+ */
+
+/*
+ * decode_B.c
+ *
+ * This file contains definition of funtions for decoding.
+ * Decoding of lower-band, including normal-decoding and RCU decoding.
+ * 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 "codec.h"
+#include "entropy_coding.h"
+#include "pitch_estimator.h"
+#include "bandwidth_estimator.h"
+#include "structs.h"
+#include "settings.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+/*
+ * function to decode the bitstream
+ * returns the total number of bytes in the stream
+ */
+int WebRtcIsac_DecodeLb(const TransformTables* transform_tables,
+                        float* signal_out, ISACLBDecStruct* ISACdecLB_obj,
+                        int16_t* current_framesamples,
+                        int16_t isRCUPayload) {
+  int k;
+  int len, err;
+  int16_t bandwidthInd;
+
+  float LP_dec_float[FRAMESAMPLES_HALF];
+  float HP_dec_float[FRAMESAMPLES_HALF];
+
+  double LPw[FRAMESAMPLES_HALF];
+  double HPw[FRAMESAMPLES_HALF];
+  double LPw_pf[FRAMESAMPLES_HALF];
+
+  double lo_filt_coef[(ORDERLO + 1)*SUBFRAMES];
+  double hi_filt_coef[(ORDERHI + 1)*SUBFRAMES];
+
+  double real_f[FRAMESAMPLES_HALF];
+  double imag_f[FRAMESAMPLES_HALF];
+
+  double PitchLags[4];
+  double PitchGains[4];
+  double AvgPitchGain;
+  int16_t PitchGains_Q12[4];
+  int16_t AvgPitchGain_Q12;
+
+  float gain;
+
+  int frame_nb; /* counter */
+  int frame_mode; /* 0 30ms, 1 for 60ms */
+  /* Processed_samples: 480 (30, 60 ms). Cannot take other values. */
+
+  WebRtcIsac_ResetBitstream(&(ISACdecLB_obj->bitstr_obj));
+
+  len = 0;
+
+  /* Decode framelength and BW estimation - not used,
+     only for stream pointer*/
+  err = WebRtcIsac_DecodeFrameLen(&ISACdecLB_obj->bitstr_obj,
+                                  current_framesamples);
+  if (err < 0) {
+    return err;
+  }
+
+  /* Frame_mode:
+   * 0: indicates 30 ms frame (480 samples)
+   * 1: indicates 60 ms frame (960 samples) */
+  frame_mode = *current_framesamples / MAX_FRAMESAMPLES;
+
+  err = WebRtcIsac_DecodeSendBW(&ISACdecLB_obj->bitstr_obj, &bandwidthInd);
+  if (err < 0) {
+    return err;
+  }
+
+  /* One loop if it's one frame (20 or 30ms), 2 loops if 2 frames
+     bundled together (60ms). */
+  for (frame_nb = 0; frame_nb <= frame_mode; frame_nb++) {
+    /* Decode & de-quantize pitch parameters */
+    err = WebRtcIsac_DecodePitchGain(&ISACdecLB_obj->bitstr_obj,
+                                     PitchGains_Q12);
+    if (err < 0) {
+      return err;
+    }
+
+    err = WebRtcIsac_DecodePitchLag(&ISACdecLB_obj->bitstr_obj, PitchGains_Q12,
+                                    PitchLags);
+    if (err < 0) {
+      return err;
+    }
+
+    AvgPitchGain_Q12 = (PitchGains_Q12[0] + PitchGains_Q12[1] +
+        PitchGains_Q12[2] + PitchGains_Q12[3]) >> 2;
+
+    /* Decode & de-quantize filter coefficients. */
+    err = WebRtcIsac_DecodeLpc(&ISACdecLB_obj->bitstr_obj, lo_filt_coef,
+                               hi_filt_coef);
+    if (err < 0) {
+      return err;
+    }
+    /* Decode & de-quantize spectrum. */
+    len = WebRtcIsac_DecodeSpec(&ISACdecLB_obj->bitstr_obj, AvgPitchGain_Q12,
+                                kIsacLowerBand, real_f, imag_f);
+    if (len < 0) {
+      return len;
+    }
+
+    /* Inverse transform. */
+    WebRtcIsac_Spec2time(transform_tables, real_f, imag_f, LPw, HPw,
+                         &ISACdecLB_obj->fftstr_obj);
+
+    /* Convert PitchGains back to float for pitchfilter_post */
+    for (k = 0; k < 4; k++) {
+      PitchGains[k] = ((float)PitchGains_Q12[k]) / 4096;
+    }
+    if (isRCUPayload) {
+      for (k = 0; k < 240; k++) {
+        LPw[k] *= RCU_TRANSCODING_SCALE_INVERSE;
+        HPw[k] *= RCU_TRANSCODING_SCALE_INVERSE;
+      }
+    }
+
+    /* Inverse pitch filter. */
+    WebRtcIsac_PitchfilterPost(LPw, LPw_pf, &ISACdecLB_obj->pitchfiltstr_obj,
+                               PitchLags, PitchGains);
+    /* Convert AvgPitchGain back to float for computation of gain. */
+    AvgPitchGain = ((float)AvgPitchGain_Q12) / 4096;
+    gain = 1.0f - 0.45f * (float)AvgPitchGain;
+
+    for (k = 0; k < FRAMESAMPLES_HALF; k++) {
+      /* Reduce gain to compensate for pitch enhancer. */
+      LPw_pf[k] *= gain;
+    }
+
+    if (isRCUPayload) {
+      for (k = 0; k < FRAMESAMPLES_HALF; k++) {
+        /* Compensation for transcoding gain changes. */
+        LPw_pf[k] *= RCU_TRANSCODING_SCALE;
+        HPw[k] *= RCU_TRANSCODING_SCALE;
+      }
+    }
+    /* Perceptual post-filtering (using normalized lattice filter). */
+    WebRtcIsac_NormLatticeFilterAr(
+        ORDERLO, ISACdecLB_obj->maskfiltstr_obj.PostStateLoF,
+        (ISACdecLB_obj->maskfiltstr_obj).PostStateLoG, LPw_pf, lo_filt_coef,
+        LP_dec_float);
+    WebRtcIsac_NormLatticeFilterAr(
+        ORDERHI, ISACdecLB_obj->maskfiltstr_obj.PostStateHiF,
+        (ISACdecLB_obj->maskfiltstr_obj).PostStateHiG, HPw, hi_filt_coef,
+        HP_dec_float);
+
+    /* Recombine the 2 bands. */
+    WebRtcIsac_FilterAndCombineFloat(LP_dec_float, HP_dec_float,
+                                     signal_out + frame_nb * FRAMESAMPLES,
+                                     &ISACdecLB_obj->postfiltbankstr_obj);
+  }
+  return len;
+}
+
+
+/*
+ * This decode function is called when the codec is operating in 16 kHz
+ * bandwidth to decode the upperband, i.e. 8-16 kHz.
+ *
+ * Contrary to lower-band, the upper-band (8-16 kHz) is not split in
+ * frequency, but split to 12 sub-frames, i.e. twice as lower-band.
+ */
+int WebRtcIsac_DecodeUb16(const TransformTables* transform_tables,
+                          float* signal_out, ISACUBDecStruct* ISACdecUB_obj,
+                          int16_t isRCUPayload) {
+  int len, err;
+
+  double halfFrameFirst[FRAMESAMPLES_HALF];
+  double halfFrameSecond[FRAMESAMPLES_HALF];
+
+  double percepFilterParam[(UB_LPC_ORDER + 1) * (SUBFRAMES << 1) +
+                           (UB_LPC_ORDER + 1)];
+
+  double real_f[FRAMESAMPLES_HALF];
+  double imag_f[FRAMESAMPLES_HALF];
+  const int16_t kAveragePitchGain = 0; /* No pitch-gain for upper-band. */
+  len = 0;
+
+  /* Decode & de-quantize filter coefficients. */
+  memset(percepFilterParam, 0, sizeof(percepFilterParam));
+  err = WebRtcIsac_DecodeInterpolLpcUb(&ISACdecUB_obj->bitstr_obj,
+                                       percepFilterParam, isac16kHz);
+  if (err < 0) {
+    return err;
+  }
+
+  /* Decode & de-quantize spectrum. */
+  len = WebRtcIsac_DecodeSpec(&ISACdecUB_obj->bitstr_obj, kAveragePitchGain,
+                              kIsacUpperBand16, real_f, imag_f);
+  if (len < 0) {
+    return len;
+  }
+  if (isRCUPayload) {
+    int n;
+    for (n = 0; n < 240; n++) {
+      real_f[n] *= RCU_TRANSCODING_SCALE_UB_INVERSE;
+      imag_f[n] *= RCU_TRANSCODING_SCALE_UB_INVERSE;
+    }
+  }
+  /* Inverse transform. */
+  WebRtcIsac_Spec2time(transform_tables,
+                       real_f, imag_f, halfFrameFirst, halfFrameSecond,
+                       &ISACdecUB_obj->fftstr_obj);
+
+  /* Perceptual post-filtering (using normalized lattice filter). */
+  WebRtcIsac_NormLatticeFilterAr(
+      UB_LPC_ORDER, ISACdecUB_obj->maskfiltstr_obj.PostStateLoF,
+      (ISACdecUB_obj->maskfiltstr_obj).PostStateLoG, halfFrameFirst,
+      &percepFilterParam[(UB_LPC_ORDER + 1)], signal_out);
+
+  WebRtcIsac_NormLatticeFilterAr(
+      UB_LPC_ORDER, ISACdecUB_obj->maskfiltstr_obj.PostStateLoF,
+      (ISACdecUB_obj->maskfiltstr_obj).PostStateLoG, halfFrameSecond,
+      &percepFilterParam[(UB_LPC_ORDER + 1) * SUBFRAMES + (UB_LPC_ORDER + 1)],
+      &signal_out[FRAMESAMPLES_HALF]);
+
+  return len;
+}
+
+/*
+ * This decode function is called when the codec operates at 0-12 kHz
+ * bandwidth to decode the upperband, i.e. 8-12 kHz.
+ *
+ * At the encoder the upper-band is split into two band, 8-12 kHz & 12-16
+ * kHz, and only 8-12 kHz is encoded. At the decoder, 8-12 kHz band is
+ * reconstructed and 12-16 kHz replaced with zeros. Then two bands
+ * are combined, to reconstruct the upperband 8-16 kHz.
+ */
+int WebRtcIsac_DecodeUb12(const TransformTables* transform_tables,
+                          float* signal_out, ISACUBDecStruct* ISACdecUB_obj,
+                          int16_t isRCUPayload) {
+  int len, err;
+
+  float LP_dec_float[FRAMESAMPLES_HALF];
+  float HP_dec_float[FRAMESAMPLES_HALF];
+
+  double LPw[FRAMESAMPLES_HALF];
+  double HPw[FRAMESAMPLES_HALF];
+
+  double percepFilterParam[(UB_LPC_ORDER + 1)*SUBFRAMES];
+
+  double real_f[FRAMESAMPLES_HALF];
+  double imag_f[FRAMESAMPLES_HALF];
+  const int16_t kAveragePitchGain = 0; /* No pitch-gain for upper-band. */
+  len = 0;
+
+  /* Decode & dequantize filter coefficients. */
+  err = WebRtcIsac_DecodeInterpolLpcUb(&ISACdecUB_obj->bitstr_obj,
+                                       percepFilterParam, isac12kHz);
+  if (err < 0) {
+    return err;
+  }
+
+  /* Decode & de-quantize spectrum. */
+  len = WebRtcIsac_DecodeSpec(&ISACdecUB_obj->bitstr_obj, kAveragePitchGain,
+                              kIsacUpperBand12, real_f, imag_f);
+  if (len < 0) {
+    return len;
+  }
+
+  if (isRCUPayload) {
+    int n;
+    for (n = 0; n < 240; n++) {
+      real_f[n] *= RCU_TRANSCODING_SCALE_UB_INVERSE;
+      imag_f[n] *= RCU_TRANSCODING_SCALE_UB_INVERSE;
+    }
+  }
+  /* Inverse transform. */
+  WebRtcIsac_Spec2time(transform_tables,
+                       real_f, imag_f, LPw, HPw, &ISACdecUB_obj->fftstr_obj);
+  /* perceptual post-filtering (using normalized lattice filter) */
+  WebRtcIsac_NormLatticeFilterAr(UB_LPC_ORDER,
+                                 ISACdecUB_obj->maskfiltstr_obj.PostStateLoF,
+                                 (ISACdecUB_obj->maskfiltstr_obj).PostStateLoG,
+                                 LPw, percepFilterParam, LP_dec_float);
+  /* Zero for 12-16 kHz. */
+  memset(HP_dec_float, 0, sizeof(float) * (FRAMESAMPLES_HALF));
+  /* Recombine the 2 bands. */
+  WebRtcIsac_FilterAndCombineFloat(HP_dec_float, LP_dec_float, signal_out,
+                                   &ISACdecUB_obj->postfiltbankstr_obj);
+  return len;
+}
diff --git a/webrtc/modules/audio_coding/codecs/isac/main/source/decode_bwe.c b/webrtc/modules/audio_coding/codecs/isac/main/source/decode_bwe.c
new file mode 100644
index 0000000..019cc89
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/main/source/decode_bwe.c
@@ -0,0 +1,89 @@
+/*
+ *  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.
+ */
+
+#include "structs.h"
+#include "bandwidth_estimator.h"
+#include "entropy_coding.h"
+#include "codec.h"
+
+
+int
+WebRtcIsac_EstimateBandwidth(
+    BwEstimatorstr*           bwest_str,
+    Bitstr*                   streamdata,
+    size_t                packet_size,
+    uint16_t              rtp_seq_number,
+    uint32_t              send_ts,
+    uint32_t              arr_ts,
+    enum IsacSamplingRate encoderSampRate,
+    enum IsacSamplingRate decoderSampRate)
+{
+  int16_t  index;
+  int16_t  frame_samples;
+  uint32_t sendTimestampIn16kHz;
+  uint32_t arrivalTimestampIn16kHz;
+  uint32_t diffSendTime;
+  uint32_t diffArrivalTime;
+  int err;
+
+  /* decode framelength and BW estimation */
+  err = WebRtcIsac_DecodeFrameLen(streamdata, &frame_samples);
+  if(err < 0)  // error check
+  {
+    return err;
+  }
+  err = WebRtcIsac_DecodeSendBW(streamdata, &index);
+  if(err < 0)  // error check
+  {
+    return err;
+  }
+
+  /* UPDATE ESTIMATES FROM OTHER SIDE */
+  err = WebRtcIsac_UpdateUplinkBwImpl(bwest_str, index, encoderSampRate);
+  if(err < 0)
+  {
+    return err;
+  }
+
+  // We like BWE to work at 16 kHz sampling rate,
+  // therefore, we have to change the timestamps accordingly.
+  // translate the send timestamp if required
+  diffSendTime = (uint32_t)((uint32_t)send_ts -
+                                  (uint32_t)bwest_str->senderTimestamp);
+  bwest_str->senderTimestamp = send_ts;
+
+  diffArrivalTime = (uint32_t)((uint32_t)arr_ts -
+                                     (uint32_t)bwest_str->receiverTimestamp);
+  bwest_str->receiverTimestamp = arr_ts;
+
+  if(decoderSampRate == kIsacSuperWideband)
+  {
+    diffArrivalTime = (uint32_t)diffArrivalTime >> 1;
+    diffSendTime = (uint32_t)diffSendTime >> 1;
+  }
+
+  // arrival timestamp in 16 kHz
+  arrivalTimestampIn16kHz = (uint32_t)((uint32_t)
+                                             bwest_str->prev_rec_arr_ts + (uint32_t)diffArrivalTime);
+  // send timestamp in 16 kHz
+  sendTimestampIn16kHz = (uint32_t)((uint32_t)
+                                          bwest_str->prev_rec_send_ts + (uint32_t)diffSendTime);
+
+  err = WebRtcIsac_UpdateBandwidthEstimator(bwest_str, rtp_seq_number,
+                                            (frame_samples * 1000) / FS, sendTimestampIn16kHz,
+                                            arrivalTimestampIn16kHz, packet_size);
+  // error check
+  if(err < 0)
+  {
+    return err;
+  }
+
+  return 0;
+}
diff --git a/webrtc/modules/audio_coding/codecs/isac/main/source/encode.c b/webrtc/modules/audio_coding/codecs/isac/main/source/encode.c
new file mode 100644
index 0000000..3f1912b
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/main/source/encode.c
@@ -0,0 +1,1258 @@
+/*
+ *  Copyright (c) 2012 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 <stdio.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 int16_t kLowerBandBitRate12[7] = {
+    29000, 30000, 30000, 31000, 31000, 32000, 32000 };
+static const int16_t kUpperBandBitRate12[7] = {
+    25000, 25000, 27000, 27000, 29000, 29000, 32000 };
+
+/*    50     51.2  52.4   53.6   54.8    56 */
+static const int16_t kLowerBandBitRate16[6] = {
+    31000, 31000, 32000, 32000, 32000, 32000 };
+static const int16_t 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.
+ */
+
+int16_t WebRtcIsac_RateAllocation(int32_t inRateBitPerSec,
+                                        double* rateLBBitPerSec,
+                                        double* rateUBBitPerSec,
+                                        enum ISACBandwidth* bandwidthKHz) {
+  int16_t 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 = (int16_t)((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 : ((int16_t)idxD);
+    idxErr = idxD - idx;
+    *rateLBBitPerSec = kLowerBandBitRate12[idx];
+    *rateUBBitPerSec = kUpperBandBitRate12[idx];
+
+    if (idx < 6) {
+      *rateLBBitPerSec += (int16_t)(
+          idxErr * (kLowerBandBitRate12[idx + 1] - kLowerBandBitRate12[idx]));
+      *rateUBBitPerSec += (int16_t)(
+          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 : ((int16_t)idxD);
+    idxErr = idxD - idx;
+    *rateLBBitPerSec = kLowerBandBitRate16[idx];
+    *rateUBBitPerSec  = kUpperBandBitRate16[idx];
+
+    if (idx < 5) {
+      *rateLBBitPerSec += (int16_t)(idxErr *
+          (kLowerBandBitRate16[idx + 1] -
+              kLowerBandBitRate16[idx]));
+
+      *rateUBBitPerSec += (int16_t)(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;
+}
+
+
+void WebRtcIsac_ResetBitstream(Bitstr* bit_stream) {
+  bit_stream->W_upper = 0xFFFFFFFF;
+  bit_stream->stream_index = 0;
+  bit_stream->streamval = 0;
+}
+
+int WebRtcIsac_EncodeLb(const TransformTables* transform_tables,
+                        float* in, ISACLBEncStruct* ISACencLB_obj,
+                        int16_t codingMode,
+                        int16_t 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];
+  int16_t fre[FRAMESAMPLES_HALF];   /* Q7 */
+  int16_t fim[FRAMESAMPLES_HALF];   /* Q7 */
+
+  double PitchLags[4];
+  double PitchGains[4];
+  int16_t PitchGains_Q12[4];
+  int16_t AvgPitchGain_Q12;
+
+  int frame_mode; /* 0 for 30ms, 1 for 60ms */
+  int status = 0;
+  int my_index;
+  transcode_obj transcodingParam;
+  double bytesLeftSpecCoding;
+  uint16_t payloadLimitBytes;
+
+  /* Copy new frame-length and bottleneck 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;
+
+  /* buffer speech samples (by 10ms packet) until the frame-length */
+  /* 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 != FRAMESAMPLES) {
+    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 */
+    WebRtcIsac_ResetBitstream(&(ISACencLB_obj->bitstr_obj));
+
+    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] = (int16_t)(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, &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,
+                             &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(transform_tables,
+                       LPw_pf, HPw, fre, fim, &ISACencLB_obj->fftstr_obj);
+
+  /* Save data for multiple packets memory. */
+  my_index = ISACencLB_obj->SaveEnc_obj.startIdx * FRAMESAMPLES_HALF;
+  memcpy(&ISACencLB_obj->SaveEnc_obj.fre[my_index], fre, sizeof(fre));
+  memcpy(&ISACencLB_obj->SaveEnc_obj.fim[my_index], fim, sizeof(fim));
+
+  ISACencLB_obj->SaveEnc_obj.AvgPitchGain[ISACencLB_obj->SaveEnc_obj.startIdx] =
+      AvgPitchGain_Q12;
+
+  /* Quantization and loss-less coding. */
+  err = WebRtcIsac_EncodeSpec(fre, fim, AvgPitchGain_Q12, kIsacLowerBand,
+                              &ISACencLB_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). */
+    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 conservative */
+      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] = (int16_t)(fre[k] * transcodeScale);
+      fim[k] = (int16_t)(fim[k] * transcodeScale);
+    }
+
+    /* Save data for multiple packets memory. */
+    my_index = ISACencLB_obj->SaveEnc_obj.startIdx * FRAMESAMPLES_HALF;
+    memcpy(&ISACencLB_obj->SaveEnc_obj.fre[my_index], fre, sizeof(fre));
+    memcpy(&ISACencLB_obj->SaveEnc_obj.fim[my_index], fim, sizeof(fim));
+
+    /* 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,
+                               &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_EncodeSpec(fre, fim, AvgPitchGain_Q12, kIsacLowerBand,
+                                &ISACencLB_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). */
+      if (frame_mode == 1 && ISACencLB_obj->frame_nb == 1) {
+        /* If this is the second 30 ms of a 60 ms frame reset
+           this such that in the next call encoder starts fresh. */
+        ISACencLB_obj->frame_nb = 0;
+      }
+      return err;
+    }
+    iterCntr++;
+  }
+
+  /* If 60 ms frame-size and just processed the first 30 ms, */
+  /* go back to main function to buffer the other 30 ms 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 frame-length 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;
+}
+
+
+
+static int LimitPayloadUb(ISACUBEncStruct* ISACencUB_obj,
+                          uint16_t payloadLimitBytes,
+                          double bytesLeftSpecCoding,
+                          transcode_obj* transcodingParam,
+                          int16_t* fre, int16_t* fim,
+                          double* lpcGains, enum ISACBand band, int status) {
+
+  int iterCntr = 0;
+  int k;
+  double bytesSpecCoderUsed;
+  double transcodeScale;
+  const int16_t kAveragePitchGain = 0.0;
+
+  do {
+    if (iterCntr >= MAX_PAYLOAD_LIMIT_ITERATION) {
+      /* We were not able to limit the payload size. */
+      return -ISAC_PAYLOAD_LARGER_THAN_LIMIT;
+    }
+
+    if (status == -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. */
+    if (band == kIsacUpperBand16) {
+      /* Two sets of coefficients if 16 kHz. */
+      for (k = 0; k < SUBFRAMES; k++) {
+        transcodingParam->loFiltGain[k] *= transcodeScale;
+        transcodingParam->hiFiltGain[k] *= transcodeScale;
+      }
+    } else {
+      /* One sets of coefficients if 12 kHz. */
+      for (k = 0; k < SUBFRAMES; k++) {
+        transcodingParam->loFiltGain[k] *= transcodeScale;
+      }
+    }
+
+    /* Scale DFT coefficients. */
+    for (k = 0; k < FRAMESAMPLES_HALF; k++) {
+      fre[k] = (int16_t)(fre[k] * transcodeScale + 0.5);
+      fim[k] = (int16_t)(fim[k] * transcodeScale + 0.5);
+    }
+    /* Store FFT coefficients for multiple encoding. */
+    memcpy(ISACencUB_obj->SaveEnc_obj.realFFT, fre,
+          sizeof(ISACencUB_obj->SaveEnc_obj.realFFT));
+    memcpy(ISACencUB_obj->SaveEnc_obj.imagFFT, fim,
+           sizeof(ISACencUB_obj->SaveEnc_obj.imagFFT));
+
+    /* 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));
+    /* Entropy Code lpc-gains, indices are stored for a later use.*/
+    WebRtcIsac_EncodeLpcGainUb(transcodingParam->loFiltGain,
+                               &ISACencUB_obj->bitstr_obj,
+                               ISACencUB_obj->SaveEnc_obj.lpcGainIndex);
+
+    /* If 16kHz should do one more set. */
+    if (band == kIsacUpperBand16) {
+      /* Store the gains for multiple encoding. */
+      memcpy(&ISACencUB_obj->SaveEnc_obj.lpcGain[SUBFRAMES],
+             &lpcGains[SUBFRAMES], SUBFRAMES * sizeof(double));
+      /* Entropy Code lpc-gains, indices are stored for a later use.*/
+      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. */
+    status = WebRtcIsac_EncodeSpec(fre, fim, kAveragePitchGain,
+                                   band, &ISACencUB_obj->bitstr_obj);
+    if ((status < 0) && (status != -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
+      /* There has been an error but it was not too large payload
+         (we can cure too large payload). */
+      return status;
+    }
+    iterCntr++;
+  } while ((ISACencUB_obj->bitstr_obj.stream_index > payloadLimitBytes) ||
+      (status == -ISAC_DISALLOWED_BITSTREAM_LENGTH));
+  return 0;
+}
+
+int WebRtcIsac_EncodeUb16(const TransformTables* transform_tables,
+                          float* in, ISACUBEncStruct* ISACencUB_obj,
+                          int32_t 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];
+  int16_t fre[FRAMESAMPLES_HALF];   /* Q7 */
+  int16_t 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;
+  uint16_t payloadLimitBytes;
+  double s2nr;
+  const int16_t kAveragePitchGain = 0.0;
+  int bytesLeftSpecCoding;
+
+  /* Buffer speech samples (by 10ms packet) until the frame-length is   */
+  /* reached (30 ms).                                                   */
+  /*********************************************************************/
+
+  /* fill the buffer with 10ms input data */
+  memcpy(&ISACencUB_obj->data_buffer_float[ISACencUB_obj->buffer_index], in,
+         FRAMESAMPLES_10ms * sizeof(float));
+
+  /* If buffer size is not equal to current frame-size, 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 bit-stream */
+  WebRtcIsac_ResetBitstream(&(ISACencUB_obj->bitstr_obj));
+
+  /* Encoding of bandwidth information. */
+  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];
+  }
+
+  /* LPC filtering (using normalized lattice filter), */
+  /* first half-frame. */
+  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(transform_tables,
+                       &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, sizeof(fre));
+  memcpy(ISACencUB_obj->SaveEnc_obj.imagFFT, fim, sizeof(fim));
+
+  /* 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));
+
+  /* Qantization and lossless coding */
+  /* Note that there is no pitch-gain for this band so kAveragePitchGain = 0
+   * is passed to the function. In fact, the function ignores the 3rd parameter
+   * for this band. */
+  err = WebRtcIsac_EncodeSpec(fre, fim, kAveragePitchGain, kIsacUpperBand16,
+                              &ISACencUB_obj->bitstr_obj);
+  if ((err < 0) && (err != -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
+    return err;
+  }
+
+  if ((ISACencUB_obj->bitstr_obj.stream_index > payloadLimitBytes) ||
+      (err == -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
+    err = LimitPayloadUb(ISACencUB_obj, payloadLimitBytes, bytesLeftSpecCoding,
+                         &transcodingParam, fre, fim, lpcGains,
+                         kIsacUpperBand16, err);
+  }
+  if (err < 0) {
+    return err;
+  }
+  /* Complete arithmetic coding. */
+  return WebRtcIsac_EncTerminate(&ISACencUB_obj->bitstr_obj);
+}
+
+
+int WebRtcIsac_EncodeUb12(const TransformTables* transform_tables,
+                          float* in, ISACUBEncStruct* ISACencUB_obj,
+                          int32_t jitterInfo) {
+  int err;
+  int k;
+
+  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];
+  int16_t fre[FRAMESAMPLES_HALF];   /* Q7 */
+  int16_t 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;
+  uint16_t payloadLimitBytes;
+  double s2nr;
+  const int16_t kAveragePitchGain = 0.0;
+  double bytesLeftSpecCoding;
+
+  /* Buffer speech samples (by 10ms packet) until the framelength is  */
+  /* reached (30 ms).                                                 */
+  /********************************************************************/
+
+  /* Fill the buffer with 10ms input data. */
+  memcpy(&ISACencUB_obj->data_buffer_float[ISACencUB_obj->buffer_index], in,
+         FRAMESAMPLES_10ms * sizeof(float));
+
+  /* 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 bit-stream. */
+  WebRtcIsac_ResetBitstream(&(ISACencUB_obj->bitstr_obj));
+
+  /* Encoding bandwidth information. */
+  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(HPw));
+
+  /* Transform */
+  WebRtcIsac_Time2Spec(transform_tables,
+                       LPw, HPw, fre, fim, &ISACencUB_obj->fftstr_obj);
+
+  /* Store FFT coefficients for multiple encoding. */
+  memcpy(ISACencUB_obj->SaveEnc_obj.realFFT, fre,
+         sizeof(ISACencUB_obj->SaveEnc_obj.realFFT));
+  memcpy(ISACencUB_obj->SaveEnc_obj.imagFFT, fim,
+         sizeof(ISACencUB_obj->SaveEnc_obj.imagFFT));
+
+  /* Save the bit-stream object at this point for FEC. */
+  memcpy(&ISACencUB_obj->SaveEnc_obj.bitStreamObj,
+         &ISACencUB_obj->bitstr_obj, sizeof(Bitstr));
+
+  /* Quantization and loss-less coding */
+  /* The 4th parameter to this function is pitch-gain, which is only used
+   * when encoding 0-8 kHz band, and irrelevant in this function, therefore,
+   * we insert zero here. */
+  err = WebRtcIsac_EncodeSpec(fre, fim, kAveragePitchGain, kIsacUpperBand12,
+                              &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;
+  }
+
+  if ((ISACencUB_obj->bitstr_obj.stream_index > payloadLimitBytes) ||
+      (err == -ISAC_DISALLOWED_BITSTREAM_LENGTH)) {
+    err = LimitPayloadUb(ISACencUB_obj, payloadLimitBytes, bytesLeftSpecCoding,
+                         &transcodingParam, fre, fim, lpcGains,
+                         kIsacUpperBand12, err);
+  }
+  if (err < 0) {
+    return err;
+  }
+  /* Complete arithmetic coding. */
+  return WebRtcIsac_EncTerminate(&ISACencUB_obj->bitstr_obj);
+}
+
+
+
+
+
+
+/* This function is used to create a new bit-stream with new BWE.
+   The same data as previously encoded with the function WebRtcIsac_Encoder().
+   The data needed is taken from the structure, where it was stored
+   when calling the encoder. */
+
+int WebRtcIsac_EncodeStoredDataLb(const IsacSaveEncoderData* ISACSavedEnc_obj,
+                                  Bitstr* ISACBitStr_obj, int BWnumber,
+                                  float scale) {
+  int ii;
+  int status;
+  int BWno = BWnumber;
+
+  const uint16_t* WebRtcIsac_kQPitchGainCdf_ptr[1];
+  const uint16_t** cdf;
+
+  double tmpLPCcoeffs_lo[(ORDERLO + 1)*SUBFRAMES * 2];
+  double tmpLPCcoeffs_hi[(ORDERHI + 1)*SUBFRAMES * 2];
+  int tmpLPCindex_g[12 * 2];
+  int16_t tmp_fre[FRAMESAMPLES], tmp_fim[FRAMESAMPLES];
+  const int kModel = 0;
+
+  /* Sanity Check - possible values for BWnumber is 0 - 23. */
+  if ((BWnumber < 0) || (BWnumber > 23)) {
+    return -ISAC_RANGE_ERROR_BW_ESTIMATOR;
+  }
+
+  /* Reset bit-stream. */
+  WebRtcIsac_ResetBitstream(ISACBitStr_obj);
+
+  /* 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] = (int16_t)((scale) * (float)ISACSavedEnc_obj->fre[ii]);
+      tmp_fim[ii] = (int16_t)((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 classification. */
+    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 */
+    /* Only one model exists. The entropy coding is done only for backward
+     * compatibility. */
+    WebRtcIsac_EncHistMulti(ISACBitStr_obj, &kModel,
+                            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,
+                            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],
+          &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, KLT_ORDER_GAIN);
+
+    /* Quantization and loss-less coding. */
+    status = WebRtcIsac_EncodeSpec(&tmp_fre[ii * FRAMESAMPLES_HALF],
+                                   &tmp_fim[ii * FRAMESAMPLES_HALF],
+                                   ISACSavedEnc_obj->AvgPitchGain[ii],
+                                   kIsacLowerBand, ISACBitStr_obj);
+    if (status < 0) {
+      return status;
+    }
+  }
+  /* Complete arithmetic coding. */
+  return WebRtcIsac_EncTerminate(ISACBitStr_obj);
+}
+
+
+int WebRtcIsac_EncodeStoredDataUb(
+    const ISACUBSaveEncDataStruct* ISACSavedEnc_obj,
+    Bitstr* bitStream,
+    int32_t jitterInfo,
+    float scale,
+    enum ISACBandwidth bandwidth) {
+  int n;
+  int err;
+  double lpcGain[SUBFRAMES];
+  int16_t realFFT[FRAMESAMPLES_HALF];
+  int16_t imagFFT[FRAMESAMPLES_HALF];
+  const uint16_t** shape_cdf;
+  int shape_len;
+  const int16_t kAveragePitchGain = 0.0;
+  enum ISACBand band;
+  /* Reset bitstream. */
+  WebRtcIsac_ResetBitstream(bitStream);
+
+  /* Encode jitter index. */
+  WebRtcIsac_EncodeJitterInfo(jitterInfo, bitStream);
+
+  err = WebRtcIsac_EncodeBandwidth(bandwidth, bitStream);
+  if (err < 0) {
+    return err;
+  }
+
+  /* Encode LPC-shape. */
+  if (bandwidth == isac12kHz) {
+    shape_cdf = WebRtcIsac_kLpcShapeCdfMatUb12;
+    shape_len = UB_LPC_ORDER * UB_LPC_VEC_PER_FRAME;
+    band = kIsacUpperBand12;
+  } else {
+    shape_cdf = WebRtcIsac_kLpcShapeCdfMatUb16;
+    shape_len = UB_LPC_ORDER * UB16_LPC_VEC_PER_FRAME;
+    band = kIsacUpperBand16;
+  }
+  WebRtcIsac_EncHistMulti(bitStream, ISACSavedEnc_obj->indexLPCShape,
+                          shape_cdf, shape_len);
+
+  if ((scale <= 0.0) || (scale >= 1.0)) {
+    /* We only consider scales between zero and one. */
+    WebRtcIsac_EncHistMulti(bitStream, ISACSavedEnc_obj->lpcGainIndex,
+                            WebRtcIsac_kLpcGainCdfMat, UB_LPC_GAIN_DIM);
+    if (bandwidth == isac16kHz) {
+      /* Store gain indices of the second half. */
+      WebRtcIsac_EncHistMulti(bitStream,
+                              &ISACSavedEnc_obj->lpcGainIndex[SUBFRAMES],
+                              WebRtcIsac_kLpcGainCdfMat, UB_LPC_GAIN_DIM);
+    }
+    /* Store FFT coefficients. */
+    err = WebRtcIsac_EncodeSpec(ISACSavedEnc_obj->realFFT,
+                                ISACSavedEnc_obj->imagFFT, kAveragePitchGain,
+                                band, bitStream);
+  } else {
+    /* Scale LPC gain and FFT coefficients. */
+    for (n = 0; n < SUBFRAMES; n++) {
+      lpcGain[n] = scale * ISACSavedEnc_obj->lpcGain[n];
+    }
+    /* Store LPC gains. */
+    WebRtcIsac_StoreLpcGainUb(lpcGain, bitStream);
+
+    if (bandwidth == isac16kHz) {
+      /* Scale and code the gains of the second half of the frame, if 16kHz. */
+      for (n = 0; n < SUBFRAMES; n++) {
+        lpcGain[n] = scale * ISACSavedEnc_obj->lpcGain[n + SUBFRAMES];
+      }
+      WebRtcIsac_StoreLpcGainUb(lpcGain, bitStream);
+    }
+
+    for (n = 0; n < FRAMESAMPLES_HALF; n++) {
+      realFFT[n] = (int16_t)(scale * (float)ISACSavedEnc_obj->realFFT[n] +
+          0.5f);
+      imagFFT[n] = (int16_t)(scale * (float)ISACSavedEnc_obj->imagFFT[n] +
+          0.5f);
+    }
+    /* Store FFT coefficients. */
+    err = WebRtcIsac_EncodeSpec(realFFT, imagFFT, kAveragePitchGain,
+                                band, bitStream);
+  }
+  if (err < 0) {
+    /* Error happened while encoding FFT coefficients. */
+    return err;
+  }
+
+  /* Complete arithmetic coding. */
+  return WebRtcIsac_EncTerminate(bitStream);
+}
+
+int16_t WebRtcIsac_GetRedPayloadUb(
+    const ISACUBSaveEncDataStruct* ISACSavedEncObj,
+    Bitstr*                        bitStreamObj,
+    enum ISACBandwidth             bandwidth) {
+  int n;
+  int16_t status;
+  int16_t realFFT[FRAMESAMPLES_HALF];
+  int16_t imagFFT[FRAMESAMPLES_HALF];
+  enum ISACBand band;
+  const int16_t kAveragePitchGain = 0.0;
+  /* Store bit-stream object. */
+  memcpy(bitStreamObj, &ISACSavedEncObj->bitStreamObj, sizeof(Bitstr));
+
+  /* Scale FFT coefficients. */
+  for (n = 0; n < FRAMESAMPLES_HALF; n++) {
+    realFFT[n] = (int16_t)((float)ISACSavedEncObj->realFFT[n] *
+        RCU_TRANSCODING_SCALE_UB + 0.5);
+    imagFFT[n] = (int16_t)((float)ISACSavedEncObj->imagFFT[n] *
+        RCU_TRANSCODING_SCALE_UB + 0.5);
+  }
+
+  band = (bandwidth == isac12kHz) ? kIsacUpperBand12 : kIsacUpperBand16;
+  status = WebRtcIsac_EncodeSpec(realFFT, imagFFT, kAveragePitchGain, band,
+                                 bitStreamObj);
+  if (status < 0) {
+    return status;
+  } else {
+    /* Terminate entropy coding */
+    return WebRtcIsac_EncTerminate(bitStreamObj);
+  }
+}
diff --git a/webrtc/modules/audio_coding/codecs/isac/main/source/fft.c b/webrtc/modules/audio_coding/codecs/isac/main/source/fft.c
new file mode 100644
index 0000000..c854d8c
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/main/source/fft.c
@@ -0,0 +1,943 @@
+/*
+ * Copyright(c)1995,97 Mark Olesen <olesen@me.QueensU.CA>
+ *    Queen's Univ at Kingston (Canada)
+ *
+ * Permission to use, copy, modify, and distribute this software for
+ * any purpose without fee is hereby granted, provided that this
+ * entire notice is included in all copies of any software which is
+ * or includes a copy or modification of this software and in all
+ * copies of the supporting documentation for such software.
+ *
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTY.  IN PARTICULAR, NEITHER THE AUTHOR NOR QUEEN'S
+ * UNIVERSITY AT KINGSTON MAKES ANY REPRESENTATION OR WARRANTY OF ANY
+ * KIND CONCERNING THE MERCHANTABILITY OF THIS SOFTWARE OR ITS
+ * FITNESS FOR ANY PARTICULAR PURPOSE.
+ *
+ * All of which is to say that you can do what you like with this
+ * source code provided you don't try to sell it as your own and you
+ * include an unaltered copy of this message (including the
+ * copyright).
+ *
+ * It is also implicitly understood that bug fixes and improvements
+ * should make their way back to the general Internet community so
+ * that everyone benefits.
+ *
+ * Changes:
+ *   Trivial type modifications by the WebRTC authors.
+ */
+
+
+/*
+ * File:
+ * WebRtcIsac_Fftn.c
+ *
+ * Public:
+ * WebRtcIsac_Fftn / fftnf ();
+ *
+ * Private:
+ * WebRtcIsac_Fftradix / fftradixf ();
+ *
+ * Descript:
+ * multivariate complex Fourier transform, computed in place
+ * using mixed-radix Fast Fourier Transform algorithm.
+ *
+ * Fortran code by:
+ * RC Singleton, Stanford Research Institute, Sept. 1968
+ *
+ * translated by f2c (version 19950721).
+ *
+ * int WebRtcIsac_Fftn (int ndim, const int dims[], REAL Re[], REAL Im[],
+ *     int iSign, double scaling);
+ *
+ * NDIM = the total number dimensions
+ * DIMS = a vector of array sizes
+ * if NDIM is zero then DIMS must be zero-terminated
+ *
+ * RE and IM hold the real and imaginary components of the data, and return
+ * the resulting real and imaginary Fourier coefficients.  Multidimensional
+ * data *must* be allocated contiguously.  There is no limit on the number
+ * of dimensions.
+ *
+ * ISIGN = the sign of the complex exponential (ie, forward or inverse FFT)
+ * the magnitude of ISIGN (normally 1) is used to determine the
+ * correct indexing increment (see below).
+ *
+ * SCALING = normalizing constant by which the final result is *divided*
+ * if SCALING == -1, normalize by total dimension of the transform
+ * if SCALING <  -1, normalize by the square-root of the total dimension
+ *
+ * example:
+ * tri-variate transform with Re[n1][n2][n3], Im[n1][n2][n3]
+ *
+ * int dims[3] = {n1,n2,n3}
+ * WebRtcIsac_Fftn (3, dims, Re, Im, 1, scaling);
+ *
+ *-----------------------------------------------------------------------*
+ * int WebRtcIsac_Fftradix (REAL Re[], REAL Im[], size_t nTotal, size_t nPass,
+ *   size_t nSpan, int iSign, size_t max_factors,
+ *   size_t max_perm);
+ *
+ * RE, IM - see above documentation
+ *
+ * Although there is no limit on the number of dimensions, WebRtcIsac_Fftradix() must
+ * be called once for each dimension, but the calls may be in any order.
+ *
+ * NTOTAL = the total number of complex data values
+ * NPASS  = the dimension of the current variable
+ * NSPAN/NPASS = the spacing of consecutive data values while indexing the
+ * current variable
+ * ISIGN - see above documentation
+ *
+ * example:
+ * tri-variate transform with Re[n1][n2][n3], Im[n1][n2][n3]
+ *
+ * WebRtcIsac_Fftradix (Re, Im, n1*n2*n3, n1,       n1, 1, maxf, maxp);
+ * WebRtcIsac_Fftradix (Re, Im, n1*n2*n3, n2,    n1*n2, 1, maxf, maxp);
+ * WebRtcIsac_Fftradix (Re, Im, n1*n2*n3, n3, n1*n2*n3, 1, maxf, maxp);
+ *
+ * single-variate transform,
+ *    NTOTAL = N = NSPAN = (number of complex data values),
+ *
+ * WebRtcIsac_Fftradix (Re, Im, n, n, n, 1, maxf, maxp);
+ *
+ * The data can also be stored in a single array with alternating real and
+ * imaginary parts, the magnitude of ISIGN is changed to 2 to give correct
+ * indexing increment, and data [0] and data [1] used to pass the initial
+ * addresses for the sequences of real and imaginary values,
+ *
+ * example:
+ * REAL data [2*NTOTAL];
+ * WebRtcIsac_Fftradix ( &data[0], &data[1], NTOTAL, nPass, nSpan, 2, maxf, maxp);
+ *
+ * for temporary allocation:
+ *
+ * MAX_FACTORS >= the maximum prime factor of NPASS
+ * MAX_PERM >= the number of prime factors of NPASS.  In addition,
+ * if the square-free portion K of NPASS has two or more prime
+ * factors, then MAX_PERM >= (K-1)
+ *
+ * storage in FACTOR for a maximum of 15 prime factors of NPASS. if NPASS
+ * has more than one square-free factor, the product of the square-free
+ * factors must be <= 210 array storage for maximum prime factor of 23 the
+ * following two constants should agree with the array dimensions.
+ *
+ *----------------------------------------------------------------------*/
+#include "fft.h"
+
+#include <stdlib.h>
+#include <math.h>
+
+
+
+/* double precision routine */
+static int
+WebRtcIsac_Fftradix (double Re[], double Im[],
+                    size_t nTotal, size_t nPass, size_t nSpan, int isign,
+                    int max_factors, unsigned int max_perm,
+                    FFTstr *fftstate);
+
+
+
+#ifndef M_PI
+# define M_PI 3.14159265358979323846264338327950288
+#endif
+
+#ifndef SIN60
+# define SIN60 0.86602540378443865 /* sin(60 deg) */
+# define COS72 0.30901699437494742 /* cos(72 deg) */
+# define SIN72 0.95105651629515357 /* sin(72 deg) */
+#endif
+
+# define REAL  double
+# define FFTN  WebRtcIsac_Fftn
+# define FFTNS  "fftn"
+# define FFTRADIX WebRtcIsac_Fftradix
+# define FFTRADIXS "fftradix"
+
+
+int  WebRtcIsac_Fftns(unsigned int ndim, const int dims[],
+                     double Re[],
+                     double Im[],
+                     int iSign,
+                     double scaling,
+                     FFTstr *fftstate)
+{
+
+  size_t nSpan, nPass, nTotal;
+  unsigned int i;
+  int ret, max_factors, max_perm;
+
+  /*
+   * tally the number of elements in the data array
+   * and determine the number of dimensions
+   */
+  nTotal = 1;
+  if (ndim && dims [0])
+  {
+    for (i = 0; i < ndim; i++)
+    {
+      if (dims [i] <= 0)
+      {
+        return -1;
+      }
+      nTotal *= dims [i];
+    }
+  }
+  else
+  {
+    ndim = 0;
+    for (i = 0; dims [i]; i++)
+    {
+      if (dims [i] <= 0)
+      {
+        return -1;
+      }
+      nTotal *= dims [i];
+      ndim++;
+    }
+  }
+
+  /* determine maximum number of factors and permuations */
+#if 1
+  /*
+   * follow John Beale's example, just use the largest dimension and don't
+   * worry about excess allocation.  May be someone else will do it?
+   */
+  max_factors = max_perm = 1;
+  for (i = 0; i < ndim; i++)
+  {
+    nSpan = dims [i];
+    if ((int)nSpan > max_factors)
+    {
+      max_factors = (int)nSpan;
+    }
+    if ((int)nSpan > max_perm) 
+    {
+      max_perm = (int)nSpan;
+    }
+  }
+#else
+  /* use the constants used in the original Fortran code */
+  max_factors = 23;
+  max_perm = 209;
+#endif
+  /* loop over the dimensions: */
+  nPass = 1;
+  for (i = 0; i < ndim; i++)
+  {
+    nSpan = dims [i];
+    nPass *= nSpan;
+    ret = FFTRADIX (Re, Im, nTotal, nSpan, nPass, iSign,
+                    max_factors, max_perm, fftstate);
+    /* exit, clean-up already done */
+    if (ret)
+      return ret;
+  }
+
+  /* Divide through by the normalizing constant: */
+  if (scaling && scaling != 1.0)
+  {
+    if (iSign < 0) iSign = -iSign;
+    if (scaling < 0.0)
+    {
+      scaling = (double)nTotal;
+      if (scaling < -1.0)
+        scaling = sqrt (scaling);
+    }
+    scaling = 1.0 / scaling; /* multiply is often faster */
+    for (i = 0; i < nTotal; i += iSign)
+    {
+      Re [i] *= scaling;
+      Im [i] *= scaling;
+    }
+  }
+  return 0;
+}
+
+/*
+ * singleton's mixed radix routine
+ *
+ * could move allocation out to WebRtcIsac_Fftn(), but leave it here so that it's
+ * possible to make this a standalone function
+ */
+
+static int   FFTRADIX (REAL Re[],
+                       REAL Im[],
+                       size_t nTotal,
+                       size_t nPass,
+                       size_t nSpan,
+                       int iSign,
+                       int max_factors,
+                       unsigned int max_perm,
+                       FFTstr *fftstate)
+{
+  int ii, mfactor, kspan, ispan, inc;
+  int j, jc, jf, jj, k, k1, k2, k3, k4, kk, kt, nn, ns, nt;
+
+
+  REAL radf;
+  REAL c1, c2, c3, cd, aa, aj, ak, ajm, ajp, akm, akp;
+  REAL s1, s2, s3, sd, bb, bj, bk, bjm, bjp, bkm, bkp;
+
+  REAL *Rtmp = NULL; /* temp space for real part*/
+  REAL *Itmp = NULL; /* temp space for imaginary part */
+  REAL *Cos = NULL; /* Cosine values */
+  REAL *Sin = NULL; /* Sine values */
+
+  REAL s60 = SIN60;  /* sin(60 deg) */
+  REAL c72 = COS72;  /* cos(72 deg) */
+  REAL s72 = SIN72;  /* sin(72 deg) */
+  REAL pi2 = M_PI;  /* use PI first, 2 PI later */
+
+
+  fftstate->SpaceAlloced = 0;
+  fftstate->MaxPermAlloced = 0;
+
+
+  // initialize to avoid warnings
+  k3 = c2 = c3 = s2 = s3 = 0.0;
+
+  if (nPass < 2)
+    return 0;
+
+  /*  allocate storage */
+  if (fftstate->SpaceAlloced < max_factors * sizeof (REAL))
+  {
+#ifdef SUN_BROKEN_REALLOC
+    if (!fftstate->SpaceAlloced) /* first time */
+    {
+      fftstate->SpaceAlloced = max_factors * sizeof (REAL);
+    }
+    else
+    {
+#endif
+      fftstate->SpaceAlloced = max_factors * sizeof (REAL);
+#ifdef SUN_BROKEN_REALLOC
+    }
+#endif
+  }
+  else
+  {
+    /* allow full use of alloc'd space */
+    max_factors = fftstate->SpaceAlloced / sizeof (REAL);
+  }
+  if (fftstate->MaxPermAlloced < max_perm)
+  {
+#ifdef SUN_BROKEN_REALLOC
+    if (!fftstate->MaxPermAlloced) /* first time */
+    else
+#endif
+      fftstate->MaxPermAlloced = max_perm;
+  }
+  else
+  {
+    /* allow full use of alloc'd space */
+    max_perm = fftstate->MaxPermAlloced;
+  }
+
+  /* assign pointers */
+  Rtmp = (REAL *) fftstate->Tmp0;
+  Itmp = (REAL *) fftstate->Tmp1;
+  Cos  = (REAL *) fftstate->Tmp2;
+  Sin  = (REAL *) fftstate->Tmp3;
+
+  /*
+   * Function Body
+   */
+  inc = iSign;
+  if (iSign < 0) {
+    s72 = -s72;
+    s60 = -s60;
+    pi2 = -pi2;
+    inc = -inc;  /* absolute value */
+  }
+
+  /* adjust for strange increments */
+  nt = inc * (int)nTotal;
+  ns = inc * (int)nSpan;
+  kspan = ns;
+
+  nn = nt - inc;
+  jc = ns / (int)nPass;
+  radf = pi2 * (double) jc;
+  pi2 *= 2.0;   /* use 2 PI from here on */
+
+  ii = 0;
+  jf = 0;
+  /*  determine the factors of n */
+  mfactor = 0;
+  k = (int)nPass;
+  while (k % 16 == 0) {
+    mfactor++;
+    fftstate->factor [mfactor - 1] = 4;
+    k /= 16;
+  }
+  j = 3;
+  jj = 9;
+  do {
+    while (k % jj == 0) {
+      mfactor++;
+      fftstate->factor [mfactor - 1] = j;
+      k /= jj;
+    }
+    j += 2;
+    jj = j * j;
+  } while (jj <= k);
+  if (k <= 4) {
+    kt = mfactor;
+    fftstate->factor [mfactor] = k;
+    if (k != 1)
+      mfactor++;
+  } else {
+    if (k - (k / 4 << 2) == 0) {
+      mfactor++;
+      fftstate->factor [mfactor - 1] = 2;
+      k /= 4;
+    }
+    kt = mfactor;
+    j = 2;
+    do {
+      if (k % j == 0) {
+        mfactor++;
+        fftstate->factor [mfactor - 1] = j;
+        k /= j;
+      }
+      j = ((j + 1) / 2 << 1) + 1;
+    } while (j <= k);
+  }
+  if (kt) {
+    j = kt;
+    do {
+      mfactor++;
+      fftstate->factor [mfactor - 1] = fftstate->factor [j - 1];
+      j--;
+    } while (j);
+  }
+
+  /* test that mfactors is in range */
+  if (mfactor > NFACTOR)
+  {
+    return -1;
+  }
+
+  /* compute fourier transform */
+  for (;;) {
+    sd = radf / (double) kspan;
+    cd = sin(sd);
+    cd = 2.0 * cd * cd;
+    sd = sin(sd + sd);
+    kk = 0;
+    ii++;
+
+    switch (fftstate->factor [ii - 1]) {
+      case 2:
+        /* transform for factor of 2 (including rotation factor) */
+        kspan /= 2;
+        k1 = kspan + 2;
+        do {
+          do {
+            k2 = kk + kspan;
+            ak = Re [k2];
+            bk = Im [k2];
+            Re [k2] = Re [kk] - ak;
+            Im [k2] = Im [kk] - bk;
+            Re [kk] += ak;
+            Im [kk] += bk;
+            kk = k2 + kspan;
+          } while (kk < nn);
+          kk -= nn;
+        } while (kk < jc);
+        if (kk >= kspan)
+          goto Permute_Results_Label;  /* exit infinite loop */
+        do {
+          c1 = 1.0 - cd;
+          s1 = sd;
+          do {
+            do {
+              do {
+                k2 = kk + kspan;
+                ak = Re [kk] - Re [k2];
+                bk = Im [kk] - Im [k2];
+                Re [kk] += Re [k2];
+                Im [kk] += Im [k2];
+                Re [k2] = c1 * ak - s1 * bk;
+                Im [k2] = s1 * ak + c1 * bk;
+                kk = k2 + kspan;
+              } while (kk < (nt-1));
+              k2 = kk - nt;
+              c1 = -c1;
+              kk = k1 - k2;
+            } while (kk > k2);
+            ak = c1 - (cd * c1 + sd * s1);
+            s1 = sd * c1 - cd * s1 + s1;
+            c1 = 2.0 - (ak * ak + s1 * s1);
+            s1 *= c1;
+            c1 *= ak;
+            kk += jc;
+          } while (kk < k2);
+          k1 += inc + inc;
+          kk = (k1 - kspan + 1) / 2 + jc - 1;
+        } while (kk < (jc + jc));
+        break;
+
+      case 4:   /* transform for factor of 4 */
+        ispan = kspan;
+        kspan /= 4;
+
+        do {
+          c1 = 1.0;
+          s1 = 0.0;
+          do {
+            do {
+              k1 = kk + kspan;
+              k2 = k1 + kspan;
+              k3 = k2 + kspan;
+              akp = Re [kk] + Re [k2];
+              akm = Re [kk] - Re [k2];
+              ajp = Re [k1] + Re [k3];
+              ajm = Re [k1] - Re [k3];
+              bkp = Im [kk] + Im [k2];
+              bkm = Im [kk] - Im [k2];
+              bjp = Im [k1] + Im [k3];
+              bjm = Im [k1] - Im [k3];
+              Re [kk] = akp + ajp;
+              Im [kk] = bkp + bjp;
+              ajp = akp - ajp;
+              bjp = bkp - bjp;
+              if (iSign < 0) {
+                akp = akm + bjm;
+                bkp = bkm - ajm;
+                akm -= bjm;
+                bkm += ajm;
+              } else {
+                akp = akm - bjm;
+                bkp = bkm + ajm;
+                akm += bjm;
+                bkm -= ajm;
+              }
+              /* avoid useless multiplies */
+              if (s1 == 0.0) {
+                Re [k1] = akp;
+                Re [k2] = ajp;
+                Re [k3] = akm;
+                Im [k1] = bkp;
+                Im [k2] = bjp;
+                Im [k3] = bkm;
+              } else {
+                Re [k1] = akp * c1 - bkp * s1;
+                Re [k2] = ajp * c2 - bjp * s2;
+                Re [k3] = akm * c3 - bkm * s3;
+                Im [k1] = akp * s1 + bkp * c1;
+                Im [k2] = ajp * s2 + bjp * c2;
+                Im [k3] = akm * s3 + bkm * c3;
+              }
+              kk = k3 + kspan;
+            } while (kk < nt);
+
+            c2 = c1 - (cd * c1 + sd * s1);
+            s1 = sd * c1 - cd * s1 + s1;
+            c1 = 2.0 - (c2 * c2 + s1 * s1);
+            s1 *= c1;
+            c1 *= c2;
+            /* values of c2, c3, s2, s3 that will get used next time */
+            c2 = c1 * c1 - s1 * s1;
+            s2 = 2.0 * c1 * s1;
+            c3 = c2 * c1 - s2 * s1;
+            s3 = c2 * s1 + s2 * c1;
+            kk = kk - nt + jc;
+          } while (kk < kspan);
+          kk = kk - kspan + inc;
+        } while (kk < jc);
+        if (kspan == jc)
+          goto Permute_Results_Label;  /* exit infinite loop */
+        break;
+
+      default:
+        /*  transform for odd factors */
+#ifdef FFT_RADIX4
+        return -1;
+        break;
+#else /* FFT_RADIX4 */
+        k = fftstate->factor [ii - 1];
+        ispan = kspan;
+        kspan /= k;
+
+        switch (k) {
+          case 3: /* transform for factor of 3 (optional code) */
+            do {
+              do {
+                k1 = kk + kspan;
+                k2 = k1 + kspan;
+                ak = Re [kk];
+                bk = Im [kk];
+                aj = Re [k1] + Re [k2];
+                bj = Im [k1] + Im [k2];
+                Re [kk] = ak + aj;
+                Im [kk] = bk + bj;
+                ak -= 0.5 * aj;
+                bk -= 0.5 * bj;
+                aj = (Re [k1] - Re [k2]) * s60;
+                bj = (Im [k1] - Im [k2]) * s60;
+                Re [k1] = ak - bj;
+                Re [k2] = ak + bj;
+                Im [k1] = bk + aj;
+                Im [k2] = bk - aj;
+                kk = k2 + kspan;
+              } while (kk < (nn - 1));
+              kk -= nn;
+            } while (kk < kspan);
+            break;
+
+          case 5: /*  transform for factor of 5 (optional code) */
+            c2 = c72 * c72 - s72 * s72;
+            s2 = 2.0 * c72 * s72;
+            do {
+              do {
+                k1 = kk + kspan;
+                k2 = k1 + kspan;
+                k3 = k2 + kspan;
+                k4 = k3 + kspan;
+                akp = Re [k1] + Re [k4];
+                akm = Re [k1] - Re [k4];
+                bkp = Im [k1] + Im [k4];
+                bkm = Im [k1] - Im [k4];
+                ajp = Re [k2] + Re [k3];
+                ajm = Re [k2] - Re [k3];
+                bjp = Im [k2] + Im [k3];
+                bjm = Im [k2] - Im [k3];
+                aa = Re [kk];
+                bb = Im [kk];
+                Re [kk] = aa + akp + ajp;
+                Im [kk] = bb + bkp + bjp;
+                ak = akp * c72 + ajp * c2 + aa;
+                bk = bkp * c72 + bjp * c2 + bb;
+                aj = akm * s72 + ajm * s2;
+                bj = bkm * s72 + bjm * s2;
+                Re [k1] = ak - bj;
+                Re [k4] = ak + bj;
+                Im [k1] = bk + aj;
+                Im [k4] = bk - aj;
+                ak = akp * c2 + ajp * c72 + aa;
+                bk = bkp * c2 + bjp * c72 + bb;
+                aj = akm * s2 - ajm * s72;
+                bj = bkm * s2 - bjm * s72;
+                Re [k2] = ak - bj;
+                Re [k3] = ak + bj;
+                Im [k2] = bk + aj;
+                Im [k3] = bk - aj;
+                kk = k4 + kspan;
+              } while (kk < (nn-1));
+              kk -= nn;
+            } while (kk < kspan);
+            break;
+
+          default:
+            if (k != jf) {
+              jf = k;
+              s1 = pi2 / (double) k;
+              c1 = cos(s1);
+              s1 = sin(s1);
+              if (jf > max_factors){
+                return -1;
+              }
+              Cos [jf - 1] = 1.0;
+              Sin [jf - 1] = 0.0;
+              j = 1;
+              do {
+                Cos [j - 1] = Cos [k - 1] * c1 + Sin [k - 1] * s1;
+                Sin [j - 1] = Cos [k - 1] * s1 - Sin [k - 1] * c1;
+                k--;
+                Cos [k - 1] = Cos [j - 1];
+                Sin [k - 1] = -Sin [j - 1];
+                j++;
+              } while (j < k);
+            }
+            do {
+              do {
+                k1 = kk;
+                k2 = kk + ispan;
+                ak = aa = Re [kk];
+                bk = bb = Im [kk];
+                j = 1;
+                k1 += kspan;
+                do {
+                  k2 -= kspan;
+                  j++;
+                  Rtmp [j - 1] = Re [k1] + Re [k2];
+                  ak += Rtmp [j - 1];
+                  Itmp [j - 1] = Im [k1] + Im [k2];
+                  bk += Itmp [j - 1];
+                  j++;
+                  Rtmp [j - 1] = Re [k1] - Re [k2];
+                  Itmp [j - 1] = Im [k1] - Im [k2];
+                  k1 += kspan;
+                } while (k1 < k2);
+                Re [kk] = ak;
+                Im [kk] = bk;
+                k1 = kk;
+                k2 = kk + ispan;
+                j = 1;
+                do {
+                  k1 += kspan;
+                  k2 -= kspan;
+                  jj = j;
+                  ak = aa;
+                  bk = bb;
+                  aj = 0.0;
+                  bj = 0.0;
+                  k = 1;
+                  do {
+                    k++;
+                    ak += Rtmp [k - 1] * Cos [jj - 1];
+                    bk += Itmp [k - 1] * Cos [jj - 1];
+                    k++;
+                    aj += Rtmp [k - 1] * Sin [jj - 1];
+                    bj += Itmp [k - 1] * Sin [jj - 1];
+                    jj += j;
+                    if (jj > jf) {
+                      jj -= jf;
+                    }
+                  } while (k < jf);
+                  k = jf - j;
+                  Re [k1] = ak - bj;
+                  Im [k1] = bk + aj;
+                  Re [k2] = ak + bj;
+                  Im [k2] = bk - aj;
+                  j++;
+                } while (j < k);
+                kk += ispan;
+              } while (kk < nn);
+              kk -= nn;
+            } while (kk < kspan);
+            break;
+        }
+
+        /*  multiply by rotation factor (except for factors of 2 and 4) */
+        if (ii == mfactor)
+          goto Permute_Results_Label;  /* exit infinite loop */
+        kk = jc;
+        do {
+          c2 = 1.0 - cd;
+          s1 = sd;
+          do {
+            c1 = c2;
+            s2 = s1;
+            kk += kspan;
+            do {
+              do {
+                ak = Re [kk];
+                Re [kk] = c2 * ak - s2 * Im [kk];
+                Im [kk] = s2 * ak + c2 * Im [kk];
+                kk += ispan;
+              } while (kk < nt);
+              ak = s1 * s2;
+              s2 = s1 * c2 + c1 * s2;
+              c2 = c1 * c2 - ak;
+              kk = kk - nt + kspan;
+            } while (kk < ispan);
+            c2 = c1 - (cd * c1 + sd * s1);
+            s1 += sd * c1 - cd * s1;
+            c1 = 2.0 - (c2 * c2 + s1 * s1);
+            s1 *= c1;
+            c2 *= c1;
+            kk = kk - ispan + jc;
+          } while (kk < kspan);
+          kk = kk - kspan + jc + inc;
+        } while (kk < (jc + jc));
+        break;
+#endif /* FFT_RADIX4 */
+    }
+  }
+
+  /*  permute the results to normal order---done in two stages */
+  /*  permutation for square factors of n */
+Permute_Results_Label:
+  fftstate->Perm [0] = ns;
+  if (kt) {
+    k = kt + kt + 1;
+    if (mfactor < k)
+      k--;
+    j = 1;
+    fftstate->Perm [k] = jc;
+    do {
+      fftstate->Perm [j] = fftstate->Perm [j - 1] / fftstate->factor [j - 1];
+      fftstate->Perm [k - 1] = fftstate->Perm [k] * fftstate->factor [j - 1];
+      j++;
+      k--;
+    } while (j < k);
+    k3 = fftstate->Perm [k];
+    kspan = fftstate->Perm [1];
+    kk = jc;
+    k2 = kspan;
+    j = 1;
+    if (nPass != nTotal) {
+      /*  permutation for multivariate transform */
+   Permute_Multi_Label:
+      do {
+        do {
+          k = kk + jc;
+          do {
+            /* swap Re [kk] <> Re [k2], Im [kk] <> Im [k2] */
+            ak = Re [kk]; Re [kk] = Re [k2]; Re [k2] = ak;
+            bk = Im [kk]; Im [kk] = Im [k2]; Im [k2] = bk;
+            kk += inc;
+            k2 += inc;
+          } while (kk < (k-1));
+          kk += ns - jc;
+          k2 += ns - jc;
+        } while (kk < (nt-1));
+        k2 = k2 - nt + kspan;
+        kk = kk - nt + jc;
+      } while (k2 < (ns-1));
+      do {
+        do {
+          k2 -= fftstate->Perm [j - 1];
+          j++;
+          k2 = fftstate->Perm [j] + k2;
+        } while (k2 > fftstate->Perm [j - 1]);
+        j = 1;
+        do {
+          if (kk < (k2-1))
+            goto Permute_Multi_Label;
+          kk += jc;
+          k2 += kspan;
+        } while (k2 < (ns-1));
+      } while (kk < (ns-1));
+    } else {
+      /*  permutation for single-variate transform (optional code) */
+   Permute_Single_Label:
+      do {
+        /* swap Re [kk] <> Re [k2], Im [kk] <> Im [k2] */
+        ak = Re [kk]; Re [kk] = Re [k2]; Re [k2] = ak;
+        bk = Im [kk]; Im [kk] = Im [k2]; Im [k2] = bk;
+        kk += inc;
+        k2 += kspan;
+      } while (k2 < (ns-1));
+      do {
+        do {
+          k2 -= fftstate->Perm [j - 1];
+          j++;
+          k2 = fftstate->Perm [j] + k2;
+        } while (k2 >= fftstate->Perm [j - 1]);
+        j = 1;
+        do {
+          if (kk < k2)
+            goto Permute_Single_Label;
+          kk += inc;
+          k2 += kspan;
+        } while (k2 < (ns-1));
+      } while (kk < (ns-1));
+    }
+    jc = k3;
+  }
+
+  if ((kt << 1) + 1 >= mfactor)
+    return 0;
+  ispan = fftstate->Perm [kt];
+  /* permutation for square-free factors of n */
+  j = mfactor - kt;
+  fftstate->factor [j] = 1;
+  do {
+    fftstate->factor [j - 1] *= fftstate->factor [j];
+    j--;
+  } while (j != kt);
+  kt++;
+  nn = fftstate->factor [kt - 1] - 1;
+  if (nn > (int) max_perm) {
+    return -1;
+  }
+  j = jj = 0;
+  for (;;) {
+    k = kt + 1;
+    k2 = fftstate->factor [kt - 1];
+    kk = fftstate->factor [k - 1];
+    j++;
+    if (j > nn)
+      break;    /* exit infinite loop */
+    jj += kk;
+    while (jj >= k2) {
+      jj -= k2;
+      k2 = kk;
+      k++;
+      kk = fftstate->factor [k - 1];
+      jj += kk;
+    }
+    fftstate->Perm [j - 1] = jj;
+  }
+  /*  determine the permutation cycles of length greater than 1 */
+  j = 0;
+  for (;;) {
+    do {
+      j++;
+      kk = fftstate->Perm [j - 1];
+    } while (kk < 0);
+    if (kk != j) {
+      do {
+        k = kk;
+        kk = fftstate->Perm [k - 1];
+        fftstate->Perm [k - 1] = -kk;
+      } while (kk != j);
+      k3 = kk;
+    } else {
+      fftstate->Perm [j - 1] = -j;
+      if (j == nn)
+        break;  /* exit infinite loop */
+    }
+  }
+  max_factors *= inc;
+  /*  reorder a and b, following the permutation cycles */
+  for (;;) {
+    j = k3 + 1;
+    nt -= ispan;
+    ii = nt - inc + 1;
+    if (nt < 0)
+      break;   /* exit infinite loop */
+    do {
+      do {
+        j--;
+      } while (fftstate->Perm [j - 1] < 0);
+      jj = jc;
+      do {
+        kspan = jj;
+        if (jj > max_factors) {
+          kspan = max_factors;
+        }
+        jj -= kspan;
+        k = fftstate->Perm [j - 1];
+        kk = jc * k + ii + jj;
+        k1 = kk + kspan - 1;
+        k2 = 0;
+        do {
+          k2++;
+          Rtmp [k2 - 1] = Re [k1];
+          Itmp [k2 - 1] = Im [k1];
+          k1 -= inc;
+        } while (k1 != (kk-1));
+        do {
+          k1 = kk + kspan - 1;
+          k2 = k1 - jc * (k + fftstate->Perm [k - 1]);
+          k = -fftstate->Perm [k - 1];
+          do {
+            Re [k1] = Re [k2];
+            Im [k1] = Im [k2];
+            k1 -= inc;
+            k2 -= inc;
+          } while (k1 != (kk-1));
+          kk = k2 + 1;
+        } while (k != j);
+        k1 = kk + kspan - 1;
+        k2 = 0;
+        do {
+          k2++;
+          Re [k1] = Rtmp [k2 - 1];
+          Im [k1] = Itmp [k2 - 1];
+          k1 -= inc;
+        } while (k1 != (kk-1));
+      } while (jj);
+    } while (j != 1);
+  }
+  return 0;   /* exit point here */
+}
+/* ---------------------- end-of-file (c source) ---------------------- */
+
diff --git a/webrtc/modules/audio_coding/codecs/isac/main/source/fft.h b/webrtc/modules/audio_coding/codecs/isac/main/source/fft.h
new file mode 100644
index 0000000..a42f57b
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/main/source/fft.h
@@ -0,0 +1,45 @@
+/*
+ *  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.
+ */
+
+/*--------------------------------*-C-*---------------------------------*
+ * File:
+ *       fftn.h
+ * ---------------------------------------------------------------------*
+ * Re[]:        real value array
+ * Im[]:        imaginary value array
+ * nTotal:      total number of complex values
+ * nPass:       number of elements involved in this pass of transform
+ * nSpan:       nspan/nPass = number of bytes to increment pointer
+ *              in Re[] and Im[]
+ * isign: exponent: +1 = forward  -1 = reverse
+ * scaling: normalizing constant by which the final result is *divided*
+ * scaling == -1, normalize by total dimension of the transform
+ * scaling <  -1, normalize by the square-root of the total dimension
+ *
+ * ----------------------------------------------------------------------
+ * See the comments in the code for correct usage!
+ */
+
+#ifndef WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_FFT_H_
+#define WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_FFT_H_
+
+
+#include "structs.h"
+
+
+/* double precision routine */
+
+
+int WebRtcIsac_Fftns (unsigned int ndim, const int dims[], double Re[], double Im[],
+                     int isign, double scaling, FFTstr *fftstate);
+
+
+
+#endif /* WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_FFT_H_ */
diff --git a/webrtc/modules/audio_coding/codecs/isac/main/source/isac.c b/webrtc/modules/audio_coding/codecs/isac/main/source/isac.c
new file mode 100644
index 0000000..875e7ac
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/main/source/isac.c
@@ -0,0 +1,2363 @@
+/*
+ *  Copyright (c) 2012 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.
+ */
+
+/*
+ * isac.c
+ *
+ * This C file contains the functions for the ISAC API
+ *
+ */
+
+#include "webrtc/modules/audio_coding/codecs/isac/main/include/isac.h"
+
+#include <assert.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
+#include "webrtc/modules/audio_coding/codecs/isac/main/source/bandwidth_estimator.h"
+#include "webrtc/modules/audio_coding/codecs/isac/main/source/codec.h"
+#include "webrtc/modules/audio_coding/codecs/isac/main/source/crc.h"
+#include "webrtc/modules/audio_coding/codecs/isac/main/source/entropy_coding.h"
+#include "webrtc/modules/audio_coding/codecs/isac/main/source/lpc_shape_swb16_tables.h"
+#include "webrtc/modules/audio_coding/codecs/isac/main/source/os_specific_inline.h"
+#include "webrtc/modules/audio_coding/codecs/isac/main/source/structs.h"
+
+#define BIT_MASK_DEC_INIT 0x0001
+#define BIT_MASK_ENC_INIT 0x0002
+
+#define LEN_CHECK_SUM_WORD8     4
+#define MAX_NUM_LAYERS         10
+
+
+/****************************************************************************
+ * UpdatePayloadSizeLimit(...)
+ *
+ * Call this function to update the limit on the payload size. The limit on
+ * payload size might change i) if a user ''directly changes the limit by
+ * calling xxx_setMaxPayloadSize() or xxx_setMaxRate(), or ii) indirectly
+ * when bandwidth is changing. The latter might be the result of bandwidth
+ * adaptation, or direct change of the bottleneck in instantaneous mode.
+ *
+ * This function takes the current overall limit on payload, and translates it
+ * to the limits on lower and upper-band. If the codec is in wideband mode,
+ * then the overall limit and the limit on the lower-band is the same.
+ * Otherwise, a fraction of the limit should be allocated to lower-band
+ * leaving some room for the upper-band bit-stream. That is why an update
+ * of limit is required every time that the bandwidth is changing.
+ *
+ */
+static void UpdatePayloadSizeLimit(ISACMainStruct* instISAC) {
+  int16_t lim30MsPayloadBytes = WEBRTC_SPL_MIN(
+                          (instISAC->maxPayloadSizeBytes),
+                          (instISAC->maxRateBytesPer30Ms));
+  int16_t lim60MsPayloadBytes = WEBRTC_SPL_MIN(
+                          (instISAC->maxPayloadSizeBytes),
+                          (instISAC->maxRateBytesPer30Ms << 1));
+
+  /* The only time that iSAC will have 60 ms
+   * frame-size is when operating in wideband, so
+   * there is no upper-band bit-stream. */
+
+  if (instISAC->bandwidthKHz == isac8kHz) {
+    /* At 8 kHz there is no upper-band bit-stream,
+     * therefore, the lower-band limit is the overall limit. */
+    instISAC->instLB.ISACencLB_obj.payloadLimitBytes60 =
+      lim60MsPayloadBytes;
+    instISAC->instLB.ISACencLB_obj.payloadLimitBytes30 =
+      lim30MsPayloadBytes;
+  } else {
+    /* When in super-wideband, we only have 30 ms frames.
+     * Do a rate allocation for the given limit. */
+    if (lim30MsPayloadBytes > 250) {
+      /* 4/5 to lower-band the rest for upper-band. */
+      instISAC->instLB.ISACencLB_obj.payloadLimitBytes30 =
+        (lim30MsPayloadBytes << 2) / 5;
+    } else if (lim30MsPayloadBytes > 200) {
+      /* For the interval of 200 to 250 the share of
+       * upper-band linearly grows from 20 to 50. */
+      instISAC->instLB.ISACencLB_obj.payloadLimitBytes30 =
+        (lim30MsPayloadBytes << 1) / 5 + 100;
+    } else {
+      /* Allocate only 20 for upper-band. */
+      instISAC->instLB.ISACencLB_obj.payloadLimitBytes30 =
+        lim30MsPayloadBytes - 20;
+    }
+    instISAC->instUB.ISACencUB_obj.maxPayloadSizeBytes =
+      lim30MsPayloadBytes;
+  }
+}
+
+
+/****************************************************************************
+ * UpdateBottleneck(...)
+ *
+ * This function updates the bottleneck only if the codec is operating in
+ * channel-adaptive mode. Furthermore, as the update of bottleneck might
+ * result in an update of bandwidth, therefore, the bottlenech should be
+ * updated just right before the first 10ms of a frame is pushed into encoder.
+ *
+ */
+static void UpdateBottleneck(ISACMainStruct* instISAC) {
+  /* Read the bottleneck from bandwidth estimator for the
+   * first 10 ms audio. This way, if there is a change
+   * in bandwidth, upper and lower-band will be in sync. */
+  if ((instISAC->codingMode == 0) &&
+      (instISAC->instLB.ISACencLB_obj.buffer_index == 0) &&
+      (instISAC->instLB.ISACencLB_obj.frame_nb == 0)) {
+    int32_t bottleneck =
+        WebRtcIsac_GetUplinkBandwidth(&instISAC->bwestimator_obj);
+
+    /* Adding hysteresis when increasing signal bandwidth. */
+    if ((instISAC->bandwidthKHz == isac8kHz)
+        && (bottleneck > 37000)
+        && (bottleneck < 41000)) {
+      bottleneck = 37000;
+    }
+
+    /* Switching from 12 kHz to 16 kHz is not allowed at this revision.
+     * If we let this happen, we have to take care of buffer_index and
+     * the last LPC vector. */
+    if ((instISAC->bandwidthKHz != isac16kHz) &&
+        (bottleneck > 46000)) {
+      bottleneck = 46000;
+    }
+
+    /* We might need a rate allocation. */
+    if (instISAC->encoderSamplingRateKHz == kIsacWideband) {
+      /* Wideband is the only choice we have here. */
+      instISAC->instLB.ISACencLB_obj.bottleneck =
+        (bottleneck > 32000) ? 32000 : bottleneck;
+      instISAC->bandwidthKHz = isac8kHz;
+    } else {
+      /* Do the rate-allocation and get the new bandwidth. */
+      enum ISACBandwidth bandwidth;
+      WebRtcIsac_RateAllocation(bottleneck,
+                                &(instISAC->instLB.ISACencLB_obj.bottleneck),
+                                &(instISAC->instUB.ISACencUB_obj.bottleneck),
+                                &bandwidth);
+      if (bandwidth != isac8kHz) {
+        instISAC->instLB.ISACencLB_obj.new_framelength = 480;
+      }
+      if (bandwidth != instISAC->bandwidthKHz) {
+        /* Bandwidth is changing. */
+        instISAC->bandwidthKHz = bandwidth;
+        UpdatePayloadSizeLimit(instISAC);
+        if (bandwidth == isac12kHz) {
+          instISAC->instLB.ISACencLB_obj.buffer_index = 0;
+        }
+        /* Currently we don't let the bandwidth to switch to 16 kHz
+         * if in adaptive mode. If we let this happen, we have to take
+         * care of buffer_index and the last LPC vector. */
+      }
+    }
+  }
+}
+
+
+/****************************************************************************
+ * GetSendBandwidthInfo(...)
+ *
+ * This is called to get the bandwidth info. This info is the bandwidth and
+ * the jitter of 'there-to-here' channel, estimated 'here.' These info
+ * is signaled in an in-band fashion to the other side.
+ *
+ * The call to the bandwidth estimator triggers a recursive averaging which
+ * has to be synchronized between encoder & decoder, therefore, the call to
+ * BWE should be once per packet. As the BWE info is inserted into bit-stream
+ * We need a valid info right before the encodeLB function is going to
+ * generate a bit-stream. That is when lower-band buffer has already 20ms
+ * of audio, and the 3rd block of 10ms is going to be injected into encoder.
+ *
+ * Inputs:
+ *         - instISAC          : iSAC instance.
+ *
+ * Outputs:
+ *         - bandwidthIndex    : an index which has to be encoded in
+ *                               lower-band bit-stream, indicating the
+ *                               bandwidth of there-to-here channel.
+ *         - jitterInfo        : this indicates if the jitter is high
+ *                               or low and it is encoded in upper-band
+ *                               bit-stream.
+ *
+ */
+static void GetSendBandwidthInfo(ISACMainStruct* instISAC,
+                                 int16_t* bandwidthIndex,
+                                 int16_t* jitterInfo) {
+  if ((instISAC->instLB.ISACencLB_obj.buffer_index ==
+      (FRAMESAMPLES_10ms << 1)) &&
+      (instISAC->instLB.ISACencLB_obj.frame_nb == 0)) {
+    /* Bandwidth estimation and coding. */
+    WebRtcIsac_GetDownlinkBwJitIndexImpl(&(instISAC->bwestimator_obj),
+                                         bandwidthIndex, jitterInfo,
+                                         instISAC->decoderSamplingRateKHz);
+  }
+}
+
+
+/****************************************************************************
+ * WebRtcIsac_AssignSize(...)
+ *
+ * This function returns the size of the ISAC instance, so that the instance
+ * can be created out side iSAC.
+ *
+ * Output:
+ *        - sizeinbytes       : number of bytes needed to allocate for the
+ *                              instance.
+ *
+ * Return value               : 0 - Ok
+ *                             -1 - Error
+ */
+int16_t WebRtcIsac_AssignSize(int* sizeInBytes) {
+  *sizeInBytes = sizeof(ISACMainStruct) * 2 / sizeof(int16_t);
+  return 0;
+}
+
+
+/****************************************************************************
+ * WebRtcIsac_Assign(...)
+ *
+ * This function assigns the memory already created to the ISAC instance.
+ *
+ * Input:
+ *        - ISAC_main_inst    : address of the pointer to the coder instance.
+ *        - instISAC_Addr     : the already allocated memory, where we put the
+ *                              iSAC structure.
+ *
+ * Return value               : 0 - Ok
+ *                             -1 - Error
+ */
+int16_t WebRtcIsac_Assign(ISACStruct** ISAC_main_inst,
+                          void* instISAC_Addr) {
+  if (instISAC_Addr != NULL) {
+    ISACMainStruct* instISAC = (ISACMainStruct*)instISAC_Addr;
+    instISAC->errorCode = 0;
+    instISAC->initFlag = 0;
+
+    /* Assign the address. */
+    *ISAC_main_inst = (ISACStruct*)instISAC_Addr;
+
+    /* Default is wideband. */
+    instISAC->encoderSamplingRateKHz = kIsacWideband;
+    instISAC->decoderSamplingRateKHz = kIsacWideband;
+    instISAC->bandwidthKHz           = isac8kHz;
+    instISAC->in_sample_rate_hz = 16000;
+
+    WebRtcIsac_InitTransform(&instISAC->transform_tables);
+    return 0;
+  } else {
+    return -1;
+  }
+}
+
+
+/****************************************************************************
+ * WebRtcIsac_Create(...)
+ *
+ * This function creates an ISAC instance, which will contain the state
+ * information for one coding/decoding channel.
+ *
+ * Input:
+ *        - ISAC_main_inst    : address of the pointer to the coder instance.
+ *
+ * Return value               : 0 - Ok
+ *                             -1 - Error
+ */
+int16_t WebRtcIsac_Create(ISACStruct** ISAC_main_inst) {
+  ISACMainStruct* instISAC;
+
+  if (ISAC_main_inst != NULL) {
+    instISAC = (ISACMainStruct*)malloc(sizeof(ISACMainStruct));
+    *ISAC_main_inst = (ISACStruct*)instISAC;
+    if (*ISAC_main_inst != NULL) {
+      instISAC->errorCode = 0;
+      instISAC->initFlag = 0;
+      /* Default is wideband. */
+      instISAC->bandwidthKHz = isac8kHz;
+      instISAC->encoderSamplingRateKHz = kIsacWideband;
+      instISAC->decoderSamplingRateKHz = kIsacWideband;
+      instISAC->in_sample_rate_hz = 16000;
+
+      WebRtcIsac_InitTransform(&instISAC->transform_tables);
+      return 0;
+    } else {
+      return -1;
+    }
+  } else {
+    return -1;
+  }
+}
+
+
+/****************************************************************************
+ * WebRtcIsac_Free(...)
+ *
+ * This function frees the ISAC instance created at the beginning.
+ *
+ * Input:
+ *        - ISAC_main_inst    : a ISAC instance.
+ *
+ * Return value               : 0 - Ok
+ *                             -1 - Error
+ */
+int16_t WebRtcIsac_Free(ISACStruct* ISAC_main_inst) {
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+  free(instISAC);
+  return 0;
+}
+
+
+/****************************************************************************
+ * EncoderInitLb(...) - internal function for initialization of
+ *                                Lower Band
+ * EncoderInitUb(...) - internal function for initialization of
+ *                                Upper Band
+ * WebRtcIsac_EncoderInit(...) - API function
+ *
+ * This function initializes a ISAC instance prior to the encoder calls.
+ *
+ * Input:
+ *        - ISAC_main_inst    : ISAC instance.
+ *        - CodingMode        : 0 -> Bit rate and frame length are automatically
+ *                                 adjusted to available bandwidth on
+ *                                 transmission channel, applicable just to
+ *                                 wideband mode.
+ *                              1 -> User sets a frame length and a target bit
+ *                                 rate which is taken as the maximum
+ *                                 short-term average bit rate.
+ *
+ * Return value               :  0 - Ok
+ *                              -1 - Error
+ */
+static int16_t EncoderInitLb(ISACLBStruct* instLB,
+                             int16_t codingMode,
+                             enum IsacSamplingRate sampRate) {
+  int16_t statusInit = 0;
+  int k;
+
+  /* Init stream vector to zero */
+  for (k = 0; k < STREAM_SIZE_MAX_60; k++) {
+    instLB->ISACencLB_obj.bitstr_obj.stream[k] = 0;
+  }
+
+  if ((codingMode == 1) || (sampRate == kIsacSuperWideband)) {
+    /* 30 ms frame-size if either in super-wideband or
+     * instantaneous mode (I-mode). */
+    instLB->ISACencLB_obj.new_framelength = 480;
+  } else {
+    instLB->ISACencLB_obj.new_framelength = INITIAL_FRAMESAMPLES;
+  }
+
+  WebRtcIsac_InitMasking(&instLB->ISACencLB_obj.maskfiltstr_obj);
+  WebRtcIsac_InitPreFilterbank(&instLB->ISACencLB_obj.prefiltbankstr_obj);
+  WebRtcIsac_InitPitchFilter(&instLB->ISACencLB_obj.pitchfiltstr_obj);
+  WebRtcIsac_InitPitchAnalysis(
+    &instLB->ISACencLB_obj.pitchanalysisstr_obj);
+
+  instLB->ISACencLB_obj.buffer_index = 0;
+  instLB->ISACencLB_obj.frame_nb = 0;
+  /* Default for I-mode. */
+  instLB->ISACencLB_obj.bottleneck = 32000;
+  instLB->ISACencLB_obj.current_framesamples = 0;
+  instLB->ISACencLB_obj.s2nr = 0;
+  instLB->ISACencLB_obj.payloadLimitBytes30 = STREAM_SIZE_MAX_30;
+  instLB->ISACencLB_obj.payloadLimitBytes60 = STREAM_SIZE_MAX_60;
+  instLB->ISACencLB_obj.maxPayloadBytes = STREAM_SIZE_MAX_60;
+  instLB->ISACencLB_obj.maxRateInBytes = STREAM_SIZE_MAX_30;
+  instLB->ISACencLB_obj.enforceFrameSize = 0;
+  /* Invalid value prevents getRedPayload to
+     run before encoder is called. */
+  instLB->ISACencLB_obj.lastBWIdx            = -1;
+  return statusInit;
+}
+
+static int16_t EncoderInitUb(ISACUBStruct* instUB,
+                             int16_t bandwidth) {
+  int16_t statusInit = 0;
+  int k;
+
+  /* Init stream vector to zero. */
+  for (k = 0; k < STREAM_SIZE_MAX_60; k++) {
+    instUB->ISACencUB_obj.bitstr_obj.stream[k] = 0;
+  }
+
+  WebRtcIsac_InitMasking(&instUB->ISACencUB_obj.maskfiltstr_obj);
+  WebRtcIsac_InitPreFilterbank(&instUB->ISACencUB_obj.prefiltbankstr_obj);
+
+  if (bandwidth == isac16kHz) {
+    instUB->ISACencUB_obj.buffer_index = LB_TOTAL_DELAY_SAMPLES;
+  } else {
+    instUB->ISACencUB_obj.buffer_index = 0;
+  }
+  /* Default for I-mode. */
+  instUB->ISACencUB_obj.bottleneck = 32000;
+  /* These store the limits for the wideband + super-wideband bit-stream. */
+  instUB->ISACencUB_obj.maxPayloadSizeBytes = STREAM_SIZE_MAX_30 << 1;
+  /* This has to be updated after each lower-band encoding to guarantee
+   * a correct payload-limitation. */
+  instUB->ISACencUB_obj.numBytesUsed = 0;
+  memset(instUB->ISACencUB_obj.data_buffer_float, 0,
+         (MAX_FRAMESAMPLES + LB_TOTAL_DELAY_SAMPLES) * sizeof(float));
+
+  memcpy(&(instUB->ISACencUB_obj.lastLPCVec),
+         WebRtcIsac_kMeanLarUb16, sizeof(double) * UB_LPC_ORDER);
+
+  return statusInit;
+}
+
+
+int16_t WebRtcIsac_EncoderInit(ISACStruct* ISAC_main_inst,
+                               int16_t codingMode) {
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+  int16_t status;
+
+  if ((codingMode != 0) && (codingMode != 1)) {
+    instISAC->errorCode = ISAC_DISALLOWED_CODING_MODE;
+    return -1;
+  }
+  /* Default bottleneck. */
+  instISAC->bottleneck = MAX_ISAC_BW;
+
+  if (instISAC->encoderSamplingRateKHz == kIsacWideband) {
+    instISAC->bandwidthKHz = isac8kHz;
+    instISAC->maxPayloadSizeBytes = STREAM_SIZE_MAX_60;
+    instISAC->maxRateBytesPer30Ms = STREAM_SIZE_MAX_30;
+  } else {
+    instISAC->bandwidthKHz = isac16kHz;
+    instISAC->maxPayloadSizeBytes = STREAM_SIZE_MAX;
+    instISAC->maxRateBytesPer30Ms = STREAM_SIZE_MAX;
+  }
+
+  /* Channel-adaptive = 0; Instantaneous (Channel-independent) = 1. */
+  instISAC->codingMode = codingMode;
+
+  WebRtcIsac_InitBandwidthEstimator(&instISAC->bwestimator_obj,
+                                    instISAC->encoderSamplingRateKHz,
+                                    instISAC->decoderSamplingRateKHz);
+
+  WebRtcIsac_InitRateModel(&instISAC->rate_data_obj);
+  /* Default for I-mode. */
+  instISAC->MaxDelay = 10.0;
+
+  status = EncoderInitLb(&instISAC->instLB, codingMode,
+                         instISAC->encoderSamplingRateKHz);
+  if (status < 0) {
+    instISAC->errorCode = -status;
+    return -1;
+  }
+
+  if (instISAC->encoderSamplingRateKHz == kIsacSuperWideband) {
+    /* Initialize encoder filter-bank. */
+    memset(instISAC->analysisFBState1, 0,
+           FB_STATE_SIZE_WORD32 * sizeof(int32_t));
+    memset(instISAC->analysisFBState2, 0,
+           FB_STATE_SIZE_WORD32 * sizeof(int32_t));
+
+    status = EncoderInitUb(&(instISAC->instUB),
+                           instISAC->bandwidthKHz);
+    if (status < 0) {
+      instISAC->errorCode = -status;
+      return -1;
+    }
+  }
+  /* Initialization is successful, set the flag. */
+  instISAC->initFlag |= BIT_MASK_ENC_INIT;
+  return 0;
+}
+
+
+/****************************************************************************
+ * WebRtcIsac_Encode(...)
+ *
+ * This function encodes 10ms frame(s) and inserts it into a package.
+ * Input speech length has to be 160 samples (10ms). The encoder buffers those
+ * 10ms frames until it reaches the chosen Framesize (480 or 960 samples
+ * corresponding to 30 or 60 ms frames), and then proceeds to the encoding.
+ *
+ * Input:
+ *        - ISAC_main_inst    : ISAC instance.
+ *        - speechIn          : input speech vector.
+ *
+ * Output:
+ *        - encoded           : the encoded data vector
+ *
+ * Return value:
+ *                            : >0 - Length (in bytes) of coded data
+ *                            :  0 - The buffer didn't reach the chosen
+ *                                  frameSize so it keeps buffering speech
+ *                                 samples.
+ *                            : -1 - Error
+ */
+int WebRtcIsac_Encode(ISACStruct* ISAC_main_inst,
+                      const int16_t* speechIn,
+                      uint8_t* encoded) {
+  float inFrame[FRAMESAMPLES_10ms];
+  int16_t speechInLB[FRAMESAMPLES_10ms];
+  int16_t speechInUB[FRAMESAMPLES_10ms];
+  int streamLenLB = 0;
+  int streamLenUB = 0;
+  int streamLen = 0;
+  size_t k = 0;
+  uint8_t garbageLen = 0;
+  int32_t bottleneck = 0;
+  int16_t bottleneckIdx = 0;
+  int16_t jitterInfo = 0;
+
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+  ISACLBStruct* instLB = &(instISAC->instLB);
+  ISACUBStruct* instUB = &(instISAC->instUB);
+
+  /* Check if encoder initiated. */
+  if ((instISAC->initFlag & BIT_MASK_ENC_INIT) !=
+      BIT_MASK_ENC_INIT) {
+    instISAC->errorCode = ISAC_ENCODER_NOT_INITIATED;
+    return -1;
+  }
+
+  if (instISAC->encoderSamplingRateKHz == kIsacSuperWideband) {
+    WebRtcSpl_AnalysisQMF(speechIn, SWBFRAMESAMPLES_10ms, speechInLB,
+                          speechInUB, instISAC->analysisFBState1,
+                          instISAC->analysisFBState2);
+
+    /* Convert from fixed to floating point. */
+    for (k = 0; k < FRAMESAMPLES_10ms; k++) {
+      inFrame[k] = (float)speechInLB[k];
+    }
+  } else {
+    for (k = 0; k < FRAMESAMPLES_10ms; k++) {
+      inFrame[k] = (float) speechIn[k];
+    }
+  }
+
+  /* Add some noise to avoid denormal numbers. */
+  inFrame[0] += (float)1.23455334e-3;
+  inFrame[1] -= (float)2.04324239e-3;
+  inFrame[2] += (float)1.90854954e-3;
+  inFrame[9] += (float)1.84854878e-3;
+
+  /* This function will update the bottleneck if required. */
+  UpdateBottleneck(instISAC);
+
+  /* Get the bandwith information which has to be sent to the other side. */
+  GetSendBandwidthInfo(instISAC, &bottleneckIdx, &jitterInfo);
+
+  /* Encode lower-band. */
+  streamLenLB = WebRtcIsac_EncodeLb(&instISAC->transform_tables,
+                                    inFrame, &instLB->ISACencLB_obj,
+                                    instISAC->codingMode, bottleneckIdx);
+  if (streamLenLB < 0) {
+    return -1;
+  }
+
+  if (instISAC->encoderSamplingRateKHz == kIsacSuperWideband) {
+    instUB = &(instISAC->instUB);
+
+    /* Convert to float. */
+    for (k = 0; k < FRAMESAMPLES_10ms; k++) {
+      inFrame[k] = (float) speechInUB[k];
+    }
+
+    /* Add some noise to avoid denormal numbers. */
+    inFrame[0] += (float)1.23455334e-3;
+    inFrame[1] -= (float)2.04324239e-3;
+    inFrame[2] += (float)1.90854954e-3;
+    inFrame[9] += (float)1.84854878e-3;
+
+    /* Tell to upper-band the number of bytes used so far.
+     * This is for payload limitation. */
+    instUB->ISACencUB_obj.numBytesUsed =
+        (int16_t)(streamLenLB + 1 + LEN_CHECK_SUM_WORD8);
+    /* Encode upper-band. */
+    switch (instISAC->bandwidthKHz) {
+      case isac12kHz: {
+        streamLenUB = WebRtcIsac_EncodeUb12(&instISAC->transform_tables,
+                                            inFrame, &instUB->ISACencUB_obj,
+                                            jitterInfo);
+        break;
+      }
+      case isac16kHz: {
+        streamLenUB = WebRtcIsac_EncodeUb16(&instISAC->transform_tables,
+                                            inFrame, &instUB->ISACencUB_obj,
+                                            jitterInfo);
+        break;
+      }
+      case isac8kHz: {
+        streamLenUB = 0;
+        break;
+      }
+    }
+
+    if ((streamLenUB < 0) && (streamLenUB != -ISAC_PAYLOAD_LARGER_THAN_LIMIT)) {
+      /* An error has happened but this is not the error due to a
+       * bit-stream larger than the limit. */
+      return -1;
+    }
+
+    if (streamLenLB == 0) {
+      return 0;
+    }
+
+    /* One byte is allocated for the length. According to older decoders
+       so the length bit-stream plus one byte for size and
+       LEN_CHECK_SUM_WORD8 for the checksum should be less than or equal
+       to 255. */
+    if ((streamLenUB > (255 - (LEN_CHECK_SUM_WORD8 + 1))) ||
+        (streamLenUB == -ISAC_PAYLOAD_LARGER_THAN_LIMIT)) {
+      /* We have got a too long bit-stream we skip the upper-band
+       * bit-stream for this frame. */
+      streamLenUB = 0;
+    }
+
+    memcpy(encoded, instLB->ISACencLB_obj.bitstr_obj.stream, streamLenLB);
+    streamLen = streamLenLB;
+    if (streamLenUB > 0) {
+      encoded[streamLenLB] = (uint8_t)(streamLenUB + 1 + LEN_CHECK_SUM_WORD8);
+      memcpy(&encoded[streamLenLB + 1],
+             instUB->ISACencUB_obj.bitstr_obj.stream,
+             streamLenUB);
+      streamLen += encoded[streamLenLB];
+    } else {
+      encoded[streamLenLB] = 0;
+    }
+  } else {
+    if (streamLenLB == 0) {
+      return 0;
+    }
+    memcpy(encoded, instLB->ISACencLB_obj.bitstr_obj.stream, streamLenLB);
+    streamLenUB = 0;
+    streamLen = streamLenLB;
+  }
+
+  /* Add Garbage if required. */
+  bottleneck = WebRtcIsac_GetUplinkBandwidth(&instISAC->bwestimator_obj);
+  if (instISAC->codingMode == 0) {
+    int minBytes;
+    int limit;
+    uint8_t* ptrGarbage;
+
+    instISAC->MaxDelay = (double)WebRtcIsac_GetUplinkMaxDelay(
+                           &instISAC->bwestimator_obj);
+
+    /* Update rate model and get minimum number of bytes in this packet. */
+    minBytes = WebRtcIsac_GetMinBytes(
+        &(instISAC->rate_data_obj), streamLen,
+        instISAC->instLB.ISACencLB_obj.current_framesamples, bottleneck,
+        instISAC->MaxDelay, instISAC->bandwidthKHz);
+
+    /* Make sure MinBytes does not exceed packet size limit. */
+    if (instISAC->bandwidthKHz == isac8kHz) {
+      if (instLB->ISACencLB_obj.current_framesamples == FRAMESAMPLES) {
+        limit = instLB->ISACencLB_obj.payloadLimitBytes30;
+      } else {
+        limit = instLB->ISACencLB_obj.payloadLimitBytes60;
+      }
+    } else {
+      limit = instUB->ISACencUB_obj.maxPayloadSizeBytes;
+    }
+    minBytes = (minBytes > limit) ? limit : minBytes;
+
+    /* Make sure we don't allow more than 255 bytes of garbage data.
+     * We store the length of the garbage data in 8 bits in the bitstream,
+     * 255 is the max garbage length we can signal using 8 bits. */
+    if ((instISAC->bandwidthKHz == isac8kHz) ||
+        (streamLenUB == 0)) {
+      ptrGarbage = &encoded[streamLenLB];
+      limit = streamLen + 255;
+    } else {
+      ptrGarbage = &encoded[streamLenLB + 1 + streamLenUB];
+      limit = streamLen + (255 - encoded[streamLenLB]);
+    }
+    minBytes = (minBytes > limit) ? limit : minBytes;
+
+    garbageLen = (minBytes > streamLen) ? (uint8_t)(minBytes - streamLen) : 0;
+
+    /* Save data for creation of multiple bit-streams. */
+    /* If bit-stream too short then add garbage at the end. */
+    if (garbageLen > 0) {
+      /* Overwrite the garbage area to avoid leaking possibly sensitive data
+         over the network. This also makes the output deterministic. */
+      memset(ptrGarbage, 0, garbageLen);
+
+      /* For a correct length of the upper-band bit-stream together
+       * with the garbage. Garbage is embeded in upper-band bit-stream.
+       * That is the only way to preserve backward compatibility. */
+      if ((instISAC->bandwidthKHz == isac8kHz) ||
+          (streamLenUB == 0)) {
+        encoded[streamLenLB] = garbageLen;
+      } else {
+        encoded[streamLenLB] += garbageLen;
+        /* Write the length of the garbage at the end of the upper-band
+         *  bit-stream, if exists. This helps for sanity check. */
+        encoded[streamLenLB + 1 + streamLenUB] = garbageLen;
+
+      }
+      streamLen += garbageLen;
+    }
+  } else {
+    /* update rate model */
+    WebRtcIsac_UpdateRateModel(
+        &instISAC->rate_data_obj, streamLen,
+        instISAC->instLB.ISACencLB_obj.current_framesamples, bottleneck);
+    garbageLen = 0;
+  }
+
+  /* Generate CRC if required. */
+  if ((instISAC->bandwidthKHz != isac8kHz) && (streamLenUB > 0)) {
+    uint32_t crc;
+
+    WebRtcIsac_GetCrc((int16_t*)(&(encoded[streamLenLB + 1])),
+                      streamLenUB + garbageLen, &crc);
+#ifndef WEBRTC_ARCH_BIG_ENDIAN
+    for (k = 0; k < LEN_CHECK_SUM_WORD8; k++) {
+      encoded[streamLen - LEN_CHECK_SUM_WORD8 + k] =
+          (uint8_t)(crc >> (24 - k * 8));
+    }
+#else
+    memcpy(&encoded[streamLenLB + streamLenUB + 1], &crc, LEN_CHECK_SUM_WORD8);
+#endif
+  }
+  return streamLen;
+}
+
+
+/******************************************************************************
+ * WebRtcIsac_GetNewBitStream(...)
+ *
+ * This function returns encoded data, with the recieved bwe-index in the
+ * stream. If the rate is set to a value less than bottleneck of codec
+ * the new bistream will be re-encoded with the given target rate.
+ * It should always return a complete packet, i.e. only called once
+ * even for 60 msec frames.
+ *
+ * NOTE 1! This function does not write in the ISACStruct, it is not allowed.
+ * NOTE 2! Rates larger than the bottleneck of the codec will be limited
+ *         to the current bottleneck.
+ *
+ * Input:
+ *        - ISAC_main_inst    : ISAC instance.
+ *        - bweIndex          : Index of bandwidth estimate to put in new
+ *                              bitstream
+ *        - rate              : target rate of the transcoder is bits/sec.
+ *                              Valid values are the accepted rate in iSAC,
+ *                              i.e. 10000 to 56000.
+ *
+ * Output:
+ *        - encoded           : The encoded data vector
+ *
+ * Return value               : >0 - Length (in bytes) of coded data
+ *                              -1 - Error  or called in SWB mode
+ *                                 NOTE! No error code is written to
+ *                                 the struct since it is only allowed to read
+ *                                 the struct.
+ */
+int16_t WebRtcIsac_GetNewBitStream(ISACStruct*  ISAC_main_inst,
+                                   int16_t  bweIndex,
+                                   int16_t  jitterInfo,
+                                   int32_t  rate,
+                                   uint8_t* encoded,
+                                   int16_t  isRCU) {
+  Bitstr iSACBitStreamInst;   /* Local struct for bitstream handling */
+  int16_t streamLenLB;
+  int16_t streamLenUB;
+  int16_t totalStreamLen;
+  double gain2;
+  double gain1;
+  float scale;
+  enum ISACBandwidth bandwidthKHz;
+  double rateLB;
+  double rateUB;
+  int32_t currentBN;
+  uint32_t crc;
+#ifndef WEBRTC_ARCH_BIG_ENDIAN
+  int16_t  k;
+#endif
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+
+  if ((instISAC->initFlag & BIT_MASK_ENC_INIT) !=
+      BIT_MASK_ENC_INIT) {
+    return -1;
+  }
+
+  /* Get the bottleneck of this iSAC and limit the
+   * given rate to the current bottleneck. */
+  WebRtcIsac_GetUplinkBw(ISAC_main_inst, &currentBN);
+  if (rate > currentBN) {
+    rate = currentBN;
+  }
+
+  if (WebRtcIsac_RateAllocation(rate, &rateLB, &rateUB, &bandwidthKHz) < 0) {
+    return -1;
+  }
+
+  /* Cannot transcode from 16 kHz to 12 kHz. */
+  if ((bandwidthKHz == isac12kHz) &&
+      (instISAC->bandwidthKHz == isac16kHz)) {
+    return -1;
+  }
+
+  /* A gain [dB] for the given rate. */
+  gain1 = WebRtcIsac_GetSnr(
+      rateLB, instISAC->instLB.ISACencLB_obj.current_framesamples);
+  /* The gain [dB] of this iSAC. */
+  gain2 = WebRtcIsac_GetSnr(
+      instISAC->instLB.ISACencLB_obj.bottleneck,
+      instISAC->instLB.ISACencLB_obj.current_framesamples);
+
+  /* Scale is the ratio of two gains in normal domain. */
+  scale = (float)pow(10, (gain1 - gain2) / 20.0);
+  /* Change the scale if this is a RCU bit-stream. */
+  scale = (isRCU) ? (scale * RCU_TRANSCODING_SCALE) : scale;
+
+  streamLenLB = WebRtcIsac_EncodeStoredDataLb(
+                  &instISAC->instLB.ISACencLB_obj.SaveEnc_obj,
+                  &iSACBitStreamInst, bweIndex, scale);
+
+  if (streamLenLB < 0) {
+    return -1;
+  }
+
+  /* Convert from bytes to int16_t. */
+  memcpy(encoded, iSACBitStreamInst.stream, streamLenLB);
+
+  if (bandwidthKHz == isac8kHz) {
+    return streamLenLB;
+  }
+
+  totalStreamLen = streamLenLB;
+  /* super-wideband is always at 30ms.
+   * These gains are in dB.
+   * Gain for the given rate. */
+  gain1 = WebRtcIsac_GetSnr(rateUB, FRAMESAMPLES);
+  /* Gain of this iSAC */
+  gain2 = WebRtcIsac_GetSnr(instISAC->instUB.ISACencUB_obj.bottleneck,
+                            FRAMESAMPLES);
+
+  /* Scale is the ratio of two gains in normal domain. */
+  scale = (float)pow(10, (gain1 - gain2) / 20.0);
+
+  /* Change the scale if this is a RCU bit-stream. */
+  scale = (isRCU)? (scale * RCU_TRANSCODING_SCALE_UB) : scale;
+
+  streamLenUB = WebRtcIsac_EncodeStoredDataUb(
+                  &(instISAC->instUB.ISACencUB_obj.SaveEnc_obj),
+                  &iSACBitStreamInst, jitterInfo, scale,
+                  instISAC->bandwidthKHz);
+
+  if (streamLenUB < 0) {
+    return -1;
+  }
+
+  if (streamLenUB + 1 + LEN_CHECK_SUM_WORD8 > 255) {
+    return streamLenLB;
+  }
+
+  totalStreamLen = streamLenLB + streamLenUB + 1 + LEN_CHECK_SUM_WORD8;
+  encoded[streamLenLB] = streamLenUB + 1 + LEN_CHECK_SUM_WORD8;
+
+  memcpy(&encoded[streamLenLB + 1], iSACBitStreamInst.stream,
+         streamLenUB);
+
+  WebRtcIsac_GetCrc((int16_t*)(&(encoded[streamLenLB + 1])),
+                    streamLenUB, &crc);
+#ifndef WEBRTC_ARCH_BIG_ENDIAN
+  for (k = 0; k < LEN_CHECK_SUM_WORD8; k++) {
+    encoded[totalStreamLen - LEN_CHECK_SUM_WORD8 + k] =
+      (uint8_t)((crc >> (24 - k * 8)) & 0xFF);
+  }
+#else
+  memcpy(&encoded[streamLenLB + streamLenUB + 1], &crc,
+         LEN_CHECK_SUM_WORD8);
+#endif
+  return totalStreamLen;
+}
+
+
+/****************************************************************************
+ * DecoderInitLb(...) - internal function for initialization of
+ *                                Lower Band
+ * DecoderInitUb(...) - internal function for initialization of
+ *                                Upper Band
+ * WebRtcIsac_DecoderInit(...) - API function
+ *
+ * This function initializes a ISAC instance prior to the decoder calls.
+ *
+ * Input:
+ *        - ISAC_main_inst    : ISAC instance.
+ */
+static void DecoderInitLb(ISACLBStruct* instISAC) {
+  int i;
+  /* Initialize stream vector to zero. */
+  for (i = 0; i < STREAM_SIZE_MAX_60; i++) {
+    instISAC->ISACdecLB_obj.bitstr_obj.stream[i] = 0;
+  }
+
+  WebRtcIsac_InitMasking(&instISAC->ISACdecLB_obj.maskfiltstr_obj);
+  WebRtcIsac_InitPostFilterbank(
+    &instISAC->ISACdecLB_obj.postfiltbankstr_obj);
+  WebRtcIsac_InitPitchFilter(&instISAC->ISACdecLB_obj.pitchfiltstr_obj);
+}
+
+static void DecoderInitUb(ISACUBStruct* instISAC) {
+  int i;
+  /* Init stream vector to zero */
+  for (i = 0; i < STREAM_SIZE_MAX_60; i++) {
+    instISAC->ISACdecUB_obj.bitstr_obj.stream[i] = 0;
+  }
+
+  WebRtcIsac_InitMasking(&instISAC->ISACdecUB_obj.maskfiltstr_obj);
+  WebRtcIsac_InitPostFilterbank(
+    &instISAC->ISACdecUB_obj.postfiltbankstr_obj);
+}
+
+void WebRtcIsac_DecoderInit(ISACStruct* ISAC_main_inst) {
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+
+  DecoderInitLb(&instISAC->instLB);
+  if (instISAC->decoderSamplingRateKHz == kIsacSuperWideband) {
+    memset(instISAC->synthesisFBState1, 0,
+           FB_STATE_SIZE_WORD32 * sizeof(int32_t));
+    memset(instISAC->synthesisFBState2, 0,
+           FB_STATE_SIZE_WORD32 * sizeof(int32_t));
+    DecoderInitUb(&(instISAC->instUB));
+  }
+  if ((instISAC->initFlag & BIT_MASK_ENC_INIT) != BIT_MASK_ENC_INIT) {
+    WebRtcIsac_InitBandwidthEstimator(&instISAC->bwestimator_obj,
+                                      instISAC->encoderSamplingRateKHz,
+                                      instISAC->decoderSamplingRateKHz);
+  }
+  instISAC->initFlag |= BIT_MASK_DEC_INIT;
+  instISAC->resetFlag_8kHz = 0;
+}
+
+
+/****************************************************************************
+ * WebRtcIsac_UpdateBwEstimate(...)
+ *
+ * This function updates the estimate of the bandwidth.
+ *
+ * NOTE:
+ * The estimates of bandwidth is not valid if the sample rate of the far-end
+ * encoder is set to 48 kHz and send timestamps are increamented according to
+ * 48 kHz sampling rate.
+ *
+ * Input:
+ *        - ISAC_main_inst    : ISAC instance.
+ *        - encoded           : encoded ISAC frame(s).
+ *        - packet_size       : size of the packet.
+ *        - rtp_seq_number    : the RTP number of the packet.
+ *        - arr_ts            : the arrival time of the packet (from NetEq)
+ *                              in samples.
+ *
+ * Return value               :  0 - Ok
+ *                              -1 - Error
+ */
+int16_t WebRtcIsac_UpdateBwEstimate(ISACStruct* ISAC_main_inst,
+                                    const uint8_t* encoded,
+                                    size_t packet_size,
+                                    uint16_t rtp_seq_number,
+                                    uint32_t send_ts,
+                                    uint32_t arr_ts) {
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+  Bitstr streamdata;
+#ifndef WEBRTC_ARCH_BIG_ENDIAN
+  int k;
+#endif
+  int16_t err;
+
+  /* Check if decoder initiated. */
+  if ((instISAC->initFlag & BIT_MASK_DEC_INIT) != BIT_MASK_DEC_INIT) {
+    instISAC->errorCode = ISAC_DECODER_NOT_INITIATED;
+    return -1;
+  }
+
+  /* Check that the size of the packet is valid, and if not return without
+   * updating the bandwidth estimate. A valid size is at least 10 bytes. */
+  if (packet_size < 10) {
+    /* Return error code if the packet length is null. */
+    instISAC->errorCode = ISAC_EMPTY_PACKET;
+    return -1;
+  }
+
+  WebRtcIsac_ResetBitstream(&(streamdata));
+
+#ifndef WEBRTC_ARCH_BIG_ENDIAN
+  for (k = 0; k < 10; k++) {
+    uint16_t ek = ((const uint16_t*)encoded)[k >> 1];
+    streamdata.stream[k] = (uint8_t)((ek >> ((k & 1) << 3)) & 0xff);
+  }
+#else
+  memcpy(streamdata.stream, encoded, 10);
+#endif
+
+  err = WebRtcIsac_EstimateBandwidth(&instISAC->bwestimator_obj, &streamdata,
+                                     packet_size, rtp_seq_number, send_ts,
+                                     arr_ts, instISAC->encoderSamplingRateKHz,
+                                     instISAC->decoderSamplingRateKHz);
+  if (err < 0) {
+    /* Return error code if something went wrong. */
+    instISAC->errorCode = -err;
+    return -1;
+  }
+  return 0;
+}
+
+static int Decode(ISACStruct* ISAC_main_inst,
+                  const uint8_t* encoded,
+                  size_t lenEncodedBytes,
+                  int16_t* decoded,
+                  int16_t* speechType,
+                  int16_t isRCUPayload) {
+  /* Number of samples (480 or 960), output from decoder
+     that were actually used in the encoder/decoder
+     (determined on the fly). */
+  int16_t numSamplesLB;
+  int16_t numSamplesUB;
+  int16_t speechIdx;
+  float outFrame[MAX_FRAMESAMPLES];
+  int16_t outFrameLB[MAX_FRAMESAMPLES];
+  int16_t outFrameUB[MAX_FRAMESAMPLES];
+  int numDecodedBytesLBint;
+  size_t numDecodedBytesLB;
+  int numDecodedBytesUB;
+  size_t lenEncodedLBBytes;
+  int16_t validChecksum = 1;
+  int16_t k;
+  uint16_t numLayer;
+  size_t totSizeBytes;
+  int16_t err;
+
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+  ISACUBDecStruct* decInstUB = &(instISAC->instUB.ISACdecUB_obj);
+  ISACLBDecStruct* decInstLB = &(instISAC->instLB.ISACdecLB_obj);
+
+  /* Check if decoder initiated. */
+  if ((instISAC->initFlag & BIT_MASK_DEC_INIT) !=
+      BIT_MASK_DEC_INIT) {
+    instISAC->errorCode = ISAC_DECODER_NOT_INITIATED;
+    return -1;
+  }
+
+  if (lenEncodedBytes == 0) {
+    /* return error code if the packet length is null. */
+    instISAC->errorCode = ISAC_EMPTY_PACKET;
+    return -1;
+  }
+
+  /* The size of the encoded lower-band is bounded by
+   * STREAM_SIZE_MAX. If a payload with the size larger than STREAM_SIZE_MAX
+   * is received, it is not considered erroneous. */
+  lenEncodedLBBytes = (lenEncodedBytes > STREAM_SIZE_MAX) ?
+      STREAM_SIZE_MAX : lenEncodedBytes;
+
+  /* Copy to lower-band bit-stream structure. */
+  memcpy(instISAC->instLB.ISACdecLB_obj.bitstr_obj.stream, encoded,
+         lenEncodedLBBytes);
+
+  /* We need to initialize numSamplesLB to something; otherwise, in the test
+     for whether we should return -1 below, the compiler might generate code
+     that fools Memcheck (Valgrind) into thinking that the control flow depends
+     on the uninitialized value in numSamplesLB (since WebRtcIsac_DecodeLb will
+     not fill it in if it fails and returns -1). */
+  numSamplesLB = 0;
+
+  /* Regardless of that the current codec is setup to work in
+   * wideband or super-wideband, the decoding of the lower-band
+   * has to be performed. */
+  numDecodedBytesLBint = WebRtcIsac_DecodeLb(&instISAC->transform_tables,
+                                             outFrame, decInstLB,
+                                             &numSamplesLB, isRCUPayload);
+  numDecodedBytesLB = (size_t)numDecodedBytesLBint;
+  if ((numDecodedBytesLBint < 0) ||
+      (numDecodedBytesLB > lenEncodedLBBytes) ||
+      (numSamplesLB > MAX_FRAMESAMPLES)) {
+    instISAC->errorCode = ISAC_LENGTH_MISMATCH;
+    return -1;
+  }
+
+  /* Error Check, we accept multi-layer bit-stream This will limit number
+   * of iterations of the while loop. Even without this the number
+   * of iterations is limited. */
+  numLayer = 1;
+  totSizeBytes = numDecodedBytesLB;
+  while (totSizeBytes != lenEncodedBytes) {
+    if ((totSizeBytes > lenEncodedBytes) ||
+        (encoded[totSizeBytes] == 0) ||
+        (numLayer > MAX_NUM_LAYERS)) {
+      instISAC->errorCode = ISAC_LENGTH_MISMATCH;
+      return -1;
+    }
+    totSizeBytes += encoded[totSizeBytes];
+    numLayer++;
+  }
+
+  if (instISAC->decoderSamplingRateKHz == kIsacWideband) {
+    for (k = 0; k < numSamplesLB; k++) {
+      if (outFrame[k] > 32767) {
+        decoded[k] = 32767;
+      } else if (outFrame[k] < -32768) {
+        decoded[k] = -32768;
+      } else {
+        decoded[k] = (int16_t)WebRtcIsac_lrint(outFrame[k]);
+      }
+    }
+    numSamplesUB = 0;
+  } else {
+    uint32_t crc;
+    /* We don't accept larger than 30ms (480 samples at lower-band)
+     * frame-size. */
+    for (k = 0; k < numSamplesLB; k++) {
+      if (outFrame[k] > 32767) {
+        outFrameLB[k] = 32767;
+      } else if (outFrame[k] < -32768) {
+        outFrameLB[k] = -32768;
+      } else {
+        outFrameLB[k] = (int16_t)WebRtcIsac_lrint(outFrame[k]);
+      }
+    }
+
+    /* Check for possible error, and if upper-band stream exists. */
+    if (numDecodedBytesLB == lenEncodedBytes) {
+      /* Decoding was successful. No super-wideband bit-stream exists. */
+      numSamplesUB = numSamplesLB;
+      memset(outFrameUB, 0, sizeof(int16_t) *  numSamplesUB);
+
+      /* Prepare for the potential increase of signal bandwidth. */
+      instISAC->resetFlag_8kHz = 2;
+    } else {
+      /* This includes the checksum and the bytes that stores the length. */
+      int16_t lenNextStream = encoded[numDecodedBytesLB];
+
+      /* Is this garbage or valid super-wideband bit-stream?
+       * Check if checksum is valid. */
+      if (lenNextStream <= (LEN_CHECK_SUM_WORD8 + 1)) {
+        /* Such a small second layer cannot be super-wideband layer.
+         * It must be a short garbage. */
+        validChecksum = 0;
+      } else {
+        /* Run CRC to see if the checksum match. */
+        WebRtcIsac_GetCrc((int16_t*)(&encoded[numDecodedBytesLB + 1]),
+                          lenNextStream - LEN_CHECK_SUM_WORD8 - 1, &crc);
+
+        validChecksum = 1;
+        for (k = 0; k < LEN_CHECK_SUM_WORD8; k++) {
+          validChecksum &= (((crc >> (24 - k * 8)) & 0xFF) ==
+                            encoded[numDecodedBytesLB + lenNextStream -
+                                          LEN_CHECK_SUM_WORD8 + k]);
+        }
+      }
+
+      if (!validChecksum) {
+        /* This is a garbage, we have received a wideband
+         * bit-stream with garbage. */
+        numSamplesUB = numSamplesLB;
+        memset(outFrameUB, 0, sizeof(int16_t) * numSamplesUB);
+      } else {
+        /* A valid super-wideband biststream exists. */
+        enum ISACBandwidth bandwidthKHz;
+        int32_t maxDelayBit;
+
+        /* If we have super-wideband bit-stream, we cannot
+         * have 60 ms frame-size. */
+        if (numSamplesLB > FRAMESAMPLES) {
+          instISAC->errorCode = ISAC_LENGTH_MISMATCH;
+          return -1;
+        }
+
+        /* The rest of the bit-stream contains the upper-band
+         * bit-stream curently this is the only thing there,
+         * however, we might add more layers. */
+
+        /* Have to exclude one byte where the length is stored
+         * and last 'LEN_CHECK_SUM_WORD8' bytes where the
+         * checksum is stored. */
+        lenNextStream -= (LEN_CHECK_SUM_WORD8 + 1);
+
+        memcpy(decInstUB->bitstr_obj.stream,
+               &encoded[numDecodedBytesLB + 1], lenNextStream);
+
+        /* Reset bit-stream object, this is the first decoding. */
+        WebRtcIsac_ResetBitstream(&(decInstUB->bitstr_obj));
+
+        /* Decode jitter information. */
+        err = WebRtcIsac_DecodeJitterInfo(&decInstUB->bitstr_obj, &maxDelayBit);
+        if (err < 0) {
+          instISAC->errorCode = -err;
+          return -1;
+        }
+
+        /* Update jitter info which is in the upper-band bit-stream
+         * only if the encoder is in super-wideband. Otherwise,
+         * the jitter info is already embedded in bandwidth index
+         * and has been updated. */
+        if (instISAC->encoderSamplingRateKHz == kIsacSuperWideband) {
+          err = WebRtcIsac_UpdateUplinkJitter(
+                  &(instISAC->bwestimator_obj), maxDelayBit);
+          if (err < 0) {
+            instISAC->errorCode = -err;
+            return -1;
+          }
+        }
+
+        /* Decode bandwidth information. */
+        err = WebRtcIsac_DecodeBandwidth(&decInstUB->bitstr_obj,
+                                         &bandwidthKHz);
+        if (err < 0) {
+          instISAC->errorCode = -err;
+          return -1;
+        }
+
+        switch (bandwidthKHz) {
+          case isac12kHz: {
+            numDecodedBytesUB = WebRtcIsac_DecodeUb12(
+                &instISAC->transform_tables, outFrame, decInstUB, isRCUPayload);
+
+            /* Hang-over for transient alleviation -
+             * wait two frames to add the upper band going up from 8 kHz. */
+            if (instISAC->resetFlag_8kHz > 0) {
+              if (instISAC->resetFlag_8kHz == 2) {
+                /* Silence first and a half frame. */
+                memset(outFrame, 0, MAX_FRAMESAMPLES *
+                       sizeof(float));
+              } else {
+                const float rampStep = 2.0f / MAX_FRAMESAMPLES;
+                float rampVal = 0;
+                memset(outFrame, 0, (MAX_FRAMESAMPLES >> 1) *
+                       sizeof(float));
+
+                /* Ramp up second half of second frame. */
+                for (k = MAX_FRAMESAMPLES / 2; k < MAX_FRAMESAMPLES; k++) {
+                  outFrame[k] *= rampVal;
+                  rampVal += rampStep;
+                }
+              }
+              instISAC->resetFlag_8kHz -= 1;
+            }
+
+            break;
+          }
+          case isac16kHz: {
+            numDecodedBytesUB = WebRtcIsac_DecodeUb16(
+                &instISAC->transform_tables, outFrame, decInstUB, isRCUPayload);
+            break;
+          }
+          default:
+            return -1;
+        }
+
+        /* It might be less due to garbage. */
+        if ((numDecodedBytesUB != lenNextStream) &&
+            (numDecodedBytesUB != (lenNextStream -
+                encoded[numDecodedBytesLB + 1 + numDecodedBytesUB]))) {
+          instISAC->errorCode = ISAC_LENGTH_MISMATCH;
+          return -1;
+        }
+
+        /* If there is no error Upper-band always decodes
+         * 30 ms (480 samples). */
+        numSamplesUB = FRAMESAMPLES;
+
+        /* Convert to W16. */
+        for (k = 0; k < numSamplesUB; k++) {
+          if (outFrame[k] > 32767) {
+            outFrameUB[k] = 32767;
+          } else if (outFrame[k] < -32768) {
+            outFrameUB[k] = -32768;
+          } else {
+            outFrameUB[k] = (int16_t)WebRtcIsac_lrint(
+                              outFrame[k]);
+          }
+        }
+      }
+    }
+
+    speechIdx = 0;
+    while (speechIdx < numSamplesLB) {
+      WebRtcSpl_SynthesisQMF(&outFrameLB[speechIdx], &outFrameUB[speechIdx],
+                             FRAMESAMPLES_10ms, &decoded[(speechIdx << 1)],
+                             instISAC->synthesisFBState1,
+                             instISAC->synthesisFBState2);
+
+      speechIdx += FRAMESAMPLES_10ms;
+    }
+  }
+  *speechType = 0;
+  return (numSamplesLB + numSamplesUB);
+}
+
+
+
+
+
+
+
+/****************************************************************************
+ * WebRtcIsac_Decode(...)
+ *
+ * This function decodes a ISAC frame. Output speech length
+ * will be a multiple of 480 samples: 480 or 960 samples,
+ * depending on the  frameSize (30 or 60 ms).
+ *
+ * Input:
+ *        - ISAC_main_inst    : ISAC instance.
+ *        - encoded           : encoded ISAC frame(s)
+ *        - len               : bytes in encoded vector
+ *
+ * Output:
+ *        - decoded           : The decoded vector
+ *
+ * Return value               : >0 - number of samples in decoded vector
+ *                              -1 - Error
+ */
+
+int WebRtcIsac_Decode(ISACStruct* ISAC_main_inst,
+                      const uint8_t* encoded,
+                      size_t lenEncodedBytes,
+                      int16_t* decoded,
+                      int16_t* speechType) {
+  int16_t isRCUPayload = 0;
+  return Decode(ISAC_main_inst, encoded, lenEncodedBytes, decoded,
+                speechType, isRCUPayload);
+}
+
+/****************************************************************************
+ * WebRtcIsac_DecodeRcu(...)
+ *
+ * This function decodes a redundant (RCU) iSAC frame. Function is called in
+ * NetEq with a stored RCU payload in case of packet loss. Output speech length
+ * will be a multiple of 480 samples: 480 or 960 samples,
+ * depending on the framesize (30 or 60 ms).
+ *
+ * Input:
+ *      - ISAC_main_inst     : ISAC instance.
+ *      - encoded            : encoded ISAC RCU frame(s)
+ *      - len                : bytes in encoded vector
+ *
+ * Output:
+ *      - decoded            : The decoded vector
+ *
+ * Return value              : >0 - number of samples in decoded vector
+ *                             -1 - Error
+ */
+
+
+
+int WebRtcIsac_DecodeRcu(ISACStruct* ISAC_main_inst,
+                         const uint8_t* encoded,
+                         size_t lenEncodedBytes,
+                         int16_t* decoded,
+                         int16_t* speechType) {
+  int16_t isRCUPayload = 1;
+  return Decode(ISAC_main_inst, encoded, lenEncodedBytes, decoded,
+                speechType, isRCUPayload);
+}
+
+
+/****************************************************************************
+ * WebRtcIsac_DecodePlc(...)
+ *
+ * This function conducts PLC for ISAC frame(s). Output speech length
+ * will be a multiple of 480 samples: 480 or 960 samples,
+ * depending on the  frameSize (30 or 60 ms).
+ *
+ * Input:
+ *        - ISAC_main_inst    : ISAC instance.
+ *        - noOfLostFrames    : Number of PLC frames to produce
+ *
+ * Output:
+ *        - decoded           : The decoded vector
+ *
+ * Return value               : Number of samples in decoded PLC vector
+ */
+size_t WebRtcIsac_DecodePlc(ISACStruct* ISAC_main_inst,
+                            int16_t* decoded,
+                            size_t noOfLostFrames) {
+  size_t numSamples = 0;
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+
+  /* Limit number of frames to two = 60 millisecond.
+   * Otherwise we exceed data vectors. */
+  if (noOfLostFrames > 2) {
+    noOfLostFrames = 2;
+  }
+
+  /* Get the number of samples per frame */
+  switch (instISAC->decoderSamplingRateKHz) {
+    case kIsacWideband: {
+      numSamples = 480 * noOfLostFrames;
+      break;
+    }
+    case kIsacSuperWideband: {
+      numSamples = 960 * noOfLostFrames;
+      break;
+    }
+  }
+
+  /* Set output samples to zero. */
+  memset(decoded, 0, numSamples * sizeof(int16_t));
+  return numSamples;
+}
+
+
+/****************************************************************************
+ * ControlLb(...) - Internal function for controlling Lower Band
+ * ControlUb(...) - Internal function for controlling Upper Band
+ * WebRtcIsac_Control(...) - API function
+ *
+ * This function sets the limit on the short-term average bit rate and the
+ * frame length. Should be used only in Instantaneous mode.
+ *
+ * Input:
+ *        - ISAC_main_inst    : ISAC instance.
+ *        - rate              : limit on the short-term average bit rate,
+ *                              in bits/second (between 10000 and 32000)
+ *        - frameSize         : number of milliseconds per frame (30 or 60)
+ *
+ * Return value               : 0 - ok
+ *                             -1 - Error
+ */
+static int16_t ControlLb(ISACLBStruct* instISAC, double rate,
+                         int16_t frameSize) {
+  if ((rate >= 10000) && (rate <= 32000)) {
+    instISAC->ISACencLB_obj.bottleneck = rate;
+  } else {
+    return -ISAC_DISALLOWED_BOTTLENECK;
+  }
+
+  if ((frameSize == 30) || (frameSize == 60)) {
+    instISAC->ISACencLB_obj.new_framelength = (FS / 1000) *  frameSize;
+  } else {
+    return -ISAC_DISALLOWED_FRAME_LENGTH;
+  }
+
+  return 0;
+}
+
+static int16_t ControlUb(ISACUBStruct* instISAC, double rate) {
+  if ((rate >= 10000) && (rate <= 32000)) {
+    instISAC->ISACencUB_obj.bottleneck = rate;
+  } else {
+    return -ISAC_DISALLOWED_BOTTLENECK;
+  }
+  return 0;
+}
+
+int16_t WebRtcIsac_Control(ISACStruct* ISAC_main_inst,
+                           int32_t bottleneckBPS,
+                           int frameSize) {
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+  int16_t status;
+  double rateLB;
+  double rateUB;
+  enum ISACBandwidth bandwidthKHz;
+
+  if (instISAC->codingMode == 0) {
+    /* In adaptive mode. */
+    instISAC->errorCode = ISAC_MODE_MISMATCH;
+    return -1;
+  }
+
+  /* Check if encoder initiated */
+  if ((instISAC->initFlag & BIT_MASK_ENC_INIT) !=
+      BIT_MASK_ENC_INIT) {
+    instISAC->errorCode = ISAC_ENCODER_NOT_INITIATED;
+    return -1;
+  }
+
+  if (instISAC->encoderSamplingRateKHz == kIsacWideband) {
+    /* If the sampling rate is 16kHz then bandwith should be 8kHz,
+     * regardless of bottleneck. */
+    bandwidthKHz = isac8kHz;
+    rateLB = (bottleneckBPS > 32000) ? 32000 : bottleneckBPS;
+    rateUB = 0;
+  } else {
+    if (WebRtcIsac_RateAllocation(bottleneckBPS, &rateLB, &rateUB,
+                                  &bandwidthKHz) < 0) {
+      return -1;
+    }
+  }
+
+  if ((instISAC->encoderSamplingRateKHz == kIsacSuperWideband) &&
+      (frameSize != 30) &&
+      (bandwidthKHz != isac8kHz)) {
+    /* Cannot have 60 ms in super-wideband. */
+    instISAC->errorCode = ISAC_DISALLOWED_FRAME_LENGTH;
+    return -1;
+  }
+
+  status = ControlLb(&instISAC->instLB, rateLB, (int16_t)frameSize);
+  if (status < 0) {
+    instISAC->errorCode = -status;
+    return -1;
+  }
+  if (bandwidthKHz != isac8kHz) {
+    status = ControlUb(&(instISAC->instUB), rateUB);
+    if (status < 0) {
+      instISAC->errorCode = -status;
+      return -1;
+    }
+  }
+
+
+  /* Check if bandwidth is changing from wideband to super-wideband
+   * then we have to synch data buffer of lower & upper-band. Also
+   * clean up the upper-band data buffer. */
+
+  if ((instISAC->bandwidthKHz == isac8kHz) && (bandwidthKHz != isac8kHz)) {
+    memset(instISAC->instUB.ISACencUB_obj.data_buffer_float, 0,
+           sizeof(float) * (MAX_FRAMESAMPLES + LB_TOTAL_DELAY_SAMPLES));
+
+    if (bandwidthKHz == isac12kHz) {
+      instISAC->instUB.ISACencUB_obj.buffer_index =
+        instISAC->instLB.ISACencLB_obj.buffer_index;
+    } else {
+      instISAC->instUB.ISACencUB_obj.buffer_index =
+          LB_TOTAL_DELAY_SAMPLES + instISAC->instLB.ISACencLB_obj.buffer_index;
+
+      memcpy(&(instISAC->instUB.ISACencUB_obj.lastLPCVec),
+             WebRtcIsac_kMeanLarUb16, sizeof(double) * UB_LPC_ORDER);
+    }
+  }
+
+  /* Update the payload limit if the bandwidth is changing. */
+  if (instISAC->bandwidthKHz != bandwidthKHz) {
+    instISAC->bandwidthKHz = bandwidthKHz;
+    UpdatePayloadSizeLimit(instISAC);
+  }
+  instISAC->bottleneck = bottleneckBPS;
+  return 0;
+}
+
+void WebRtcIsac_SetInitialBweBottleneck(ISACStruct* ISAC_main_inst,
+                                        int bottleneck_bits_per_second) {
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+  assert(bottleneck_bits_per_second >= 10000 &&
+         bottleneck_bits_per_second <= 32000);
+  instISAC->bwestimator_obj.send_bw_avg = (float)bottleneck_bits_per_second;
+}
+
+/****************************************************************************
+ * WebRtcIsac_ControlBwe(...)
+ *
+ * This function sets the initial values of bottleneck and frame-size if
+ * iSAC is used in channel-adaptive mode. Through this API, users can
+ * enforce a frame-size for all values of bottleneck. Then iSAC will not
+ * automatically change the frame-size.
+ *
+ *
+ * Input:
+ *        - ISAC_main_inst    : ISAC instance.
+ *        - rateBPS           : initial value of bottleneck in bits/second
+ *                              10000 <= rateBPS <= 32000 is accepted
+ *                              For default bottleneck set rateBPS = 0
+ *        - frameSizeMs       : number of milliseconds per frame (30 or 60)
+ *        - enforceFrameSize  : 1 to enforce the given frame-size through out
+ *                              the adaptation process, 0 to let iSAC change
+ *                              the frame-size if required.
+ *
+ * Return value               : 0 - ok
+ *                             -1 - Error
+ */
+int16_t WebRtcIsac_ControlBwe(ISACStruct* ISAC_main_inst,
+                              int32_t bottleneckBPS,
+                              int frameSizeMs,
+                              int16_t enforceFrameSize) {
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+  enum ISACBandwidth bandwidth;
+
+   /* Check if encoder initiated */
+  if ((instISAC->initFlag & BIT_MASK_ENC_INIT) !=
+      BIT_MASK_ENC_INIT) {
+    instISAC->errorCode = ISAC_ENCODER_NOT_INITIATED;
+    return -1;
+  }
+
+  /* Check that we are in channel-adaptive mode, otherwise, return (-1) */
+  if (instISAC->codingMode != 0) {
+    instISAC->errorCode = ISAC_MODE_MISMATCH;
+    return -1;
+  }
+  if ((frameSizeMs != 30) &&
+      (instISAC->encoderSamplingRateKHz == kIsacSuperWideband)) {
+    return -1;
+  }
+
+  /* Set structure variable if enforceFrameSize is set. ISAC will then
+   * keep the chosen frame size. */
+  if (enforceFrameSize != 0) {
+    instISAC->instLB.ISACencLB_obj.enforceFrameSize = 1;
+  } else {
+    instISAC->instLB.ISACencLB_obj.enforceFrameSize = 0;
+  }
+
+  /* Set the initial rate. If the input value is zero then the default intial
+   * rate is used. Otehrwise, values between 10 to 32 kbps are accepted. */
+  if (bottleneckBPS != 0) {
+    double rateLB;
+    double rateUB;
+    if (WebRtcIsac_RateAllocation(bottleneckBPS, &rateLB, &rateUB,
+                                  &bandwidth) < 0) {
+      return -1;
+    }
+    instISAC->bwestimator_obj.send_bw_avg = (float)bottleneckBPS;
+    instISAC->bandwidthKHz = bandwidth;
+  }
+
+  /* Set the initial frame-size. If 'enforceFrameSize' is set, the frame-size
+   *  will not change */
+  if (frameSizeMs != 0) {
+    if ((frameSizeMs  == 30) || (frameSizeMs == 60)) {
+      instISAC->instLB.ISACencLB_obj.new_framelength =
+          (int16_t)((FS / 1000) * frameSizeMs);
+    } else {
+      instISAC->errorCode = ISAC_DISALLOWED_FRAME_LENGTH;
+      return -1;
+    }
+  }
+  return 0;
+}
+
+
+/****************************************************************************
+ * WebRtcIsac_GetDownLinkBwIndex(...)
+ *
+ * This function returns index representing the Bandwidth estimate from
+ * the other side to this side.
+ *
+ * Input:
+ *        - ISAC_main_inst    : iSAC structure
+ *
+ * Output:
+ *        - bweIndex         : Bandwidth estimate to transmit to other side.
+ *
+ */
+int16_t WebRtcIsac_GetDownLinkBwIndex(ISACStruct* ISAC_main_inst,
+                                      int16_t* bweIndex,
+                                      int16_t* jitterInfo) {
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+
+  /* Check if encoder initialized. */
+  if ((instISAC->initFlag & BIT_MASK_DEC_INIT) !=
+      BIT_MASK_DEC_INIT) {
+    instISAC->errorCode = ISAC_ENCODER_NOT_INITIATED;
+    return -1;
+  }
+
+  /* Call function to get Bandwidth Estimate. */
+  WebRtcIsac_GetDownlinkBwJitIndexImpl(&(instISAC->bwestimator_obj), bweIndex,
+                                       jitterInfo,
+                                       instISAC->decoderSamplingRateKHz);
+  return 0;
+}
+
+
+/****************************************************************************
+ * WebRtcIsac_UpdateUplinkBw(...)
+ *
+ * This function takes an index representing the Bandwidth estimate from
+ * this side to other side and updates BWE.
+ *
+ * Input:
+ *        - ISAC_main_inst    : iSAC structure
+ *        - rateIndex         : Bandwidth estimate from other side.
+ *
+ * Return value               : 0 - ok
+ *                             -1 - index out of range
+ */
+int16_t WebRtcIsac_UpdateUplinkBw(ISACStruct* ISAC_main_inst,
+                                  int16_t bweIndex) {
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+  int16_t returnVal;
+
+  /* Check if encoder initiated. */
+  if ((instISAC->initFlag & BIT_MASK_ENC_INIT) !=
+      BIT_MASK_ENC_INIT) {
+    instISAC->errorCode = ISAC_ENCODER_NOT_INITIATED;
+    return -1;
+  }
+
+  /* Call function to get Bandwidth Estimate. */
+  returnVal = WebRtcIsac_UpdateUplinkBwImpl(
+                &(instISAC->bwestimator_obj), bweIndex,
+                instISAC->encoderSamplingRateKHz);
+
+  if (returnVal < 0) {
+    instISAC->errorCode = -returnVal;
+    return -1;
+  } else {
+    return 0;
+  }
+}
+
+
+/****************************************************************************
+ * WebRtcIsac_ReadBwIndex(...)
+ *
+ * This function returns the index of the Bandwidth estimate from the
+ * bit-stream.
+ *
+ * Input:
+ *        - encoded           : Encoded bit-stream
+ *
+ * Output:
+ *        - frameLength       : Length of frame in packet (in samples)
+ *        - bweIndex          : Bandwidth estimate in bit-stream
+ *
+ */
+int16_t WebRtcIsac_ReadBwIndex(const uint8_t* encoded,
+                               int16_t* bweIndex) {
+  Bitstr streamdata;
+#ifndef WEBRTC_ARCH_BIG_ENDIAN
+  int k;
+#endif
+  int16_t err;
+
+  WebRtcIsac_ResetBitstream(&(streamdata));
+
+#ifndef WEBRTC_ARCH_BIG_ENDIAN
+  for (k = 0; k < 10; k++) {
+    int16_t ek2 = ((const int16_t*)encoded)[k >> 1];
+    streamdata.stream[k] = (uint8_t)((ek2 >> ((k & 1) << 3)) & 0xff);
+  }
+#else
+  memcpy(streamdata.stream, encoded, 10);
+#endif
+
+  /* Decode frame length. */
+  err = WebRtcIsac_DecodeFrameLen(&streamdata, bweIndex);
+  if (err < 0) {
+    return err;
+  }
+
+  /* Decode BW estimation. */
+  err = WebRtcIsac_DecodeSendBW(&streamdata, bweIndex);
+  if (err < 0) {
+    return err;
+  }
+
+  return 0;
+}
+
+
+/****************************************************************************
+ * WebRtcIsac_ReadFrameLen(...)
+ *
+ * This function returns the number of samples the decoder will generate if
+ * the given payload is decoded.
+ *
+ * Input:
+ *        - encoded           : Encoded bitstream
+ *
+ * Output:
+ *        - frameLength       : Length of frame in packet (in samples)
+ *
+ */
+int16_t WebRtcIsac_ReadFrameLen(ISACStruct* ISAC_main_inst,
+                                const uint8_t* encoded,
+                                int16_t* frameLength) {
+  Bitstr streamdata;
+#ifndef WEBRTC_ARCH_BIG_ENDIAN
+  int k;
+#endif
+  int16_t err;
+  ISACMainStruct* instISAC;
+
+  WebRtcIsac_ResetBitstream(&(streamdata));
+
+#ifndef WEBRTC_ARCH_BIG_ENDIAN
+  for (k = 0; k < 10; k++) {
+    int16_t ek2 = ((const int16_t*)encoded)[k >> 1];
+    streamdata.stream[k] = (uint8_t)((ek2 >> ((k & 1) << 3)) & 0xff);
+  }
+#else
+  memcpy(streamdata.stream, encoded, 10);
+#endif
+
+  /* Decode frame length. */
+  err = WebRtcIsac_DecodeFrameLen(&streamdata, frameLength);
+  if (err < 0) {
+    return -1;
+  }
+  instISAC = (ISACMainStruct*)ISAC_main_inst;
+
+  if (instISAC->decoderSamplingRateKHz == kIsacSuperWideband) {
+    /* The decoded frame length indicates the number of samples in
+     * lower-band in this case, multiply by 2 to get the total number
+     * of samples. */
+    *frameLength <<= 1;
+  }
+  return 0;
+}
+
+
+/*******************************************************************************
+ * WebRtcIsac_GetNewFrameLen(...)
+ *
+ * This function returns the frame length (in samples) of the next packet.
+ * In the case of channel-adaptive mode, iSAC decides on its frame length based
+ * on the estimated bottleneck, this AOI allows a user to prepare for the next
+ * packet (at the encoder).
+ *
+ * The primary usage is in CE to make the iSAC works in channel-adaptive mode
+ *
+ * Input:
+ *        - ISAC_main_inst     : iSAC struct
+ *
+ * Return Value                : frame lenght in samples
+ *
+ */
+int16_t WebRtcIsac_GetNewFrameLen(ISACStruct* ISAC_main_inst) {
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+
+  /* Return new frame length. */
+  if (instISAC->in_sample_rate_hz == 16000)
+    return (instISAC->instLB.ISACencLB_obj.new_framelength);
+  else  /* 32000 Hz */
+    return ((instISAC->instLB.ISACencLB_obj.new_framelength) * 2);
+}
+
+
+/****************************************************************************
+ * WebRtcIsac_GetErrorCode(...)
+ *
+ * This function can be used to check the error code of an iSAC instance.
+ * When a function returns -1 an error code will be set for that instance.
+ * The function below extracts the code of the last error that occurred in
+ * the specified instance.
+ *
+ * Input:
+ *        - ISAC_main_inst    : ISAC instance
+ *
+ * Return value               : Error code
+ */
+int16_t WebRtcIsac_GetErrorCode(ISACStruct* ISAC_main_inst) {
+ return ((ISACMainStruct*)ISAC_main_inst)->errorCode;
+}
+
+
+/****************************************************************************
+ * WebRtcIsac_GetUplinkBw(...)
+ *
+ * This function outputs the target bottleneck of the codec. In
+ * channel-adaptive mode, the target bottleneck is specified through an in-band
+ * signalling retrieved by bandwidth estimator.
+ * In channel-independent, also called instantaneous mode, the target
+ * bottleneck is provided to the encoder by calling xxx_control(...) (if
+ * xxx_control is never called, the default values are used.).
+ * Note that the output is the iSAC internal operating bottleneck which might
+ * differ slightly from the one provided through xxx_control().
+ *
+ * Input:
+ *        - ISAC_main_inst    : iSAC instance
+ *
+ * Output:
+ *        - *bottleneck       : bottleneck in bits/sec
+ *
+ * Return value               : -1 if error happens
+ *                               0 bit-rates computed correctly.
+ */
+int16_t WebRtcIsac_GetUplinkBw(ISACStruct*  ISAC_main_inst,
+                               int32_t* bottleneck) {
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+
+  if (instISAC->codingMode == 0) {
+    /* We are in adaptive mode then get the bottleneck from BWE. */
+    *bottleneck = (int32_t)instISAC->bwestimator_obj.send_bw_avg;
+  } else {
+    *bottleneck = instISAC->bottleneck;
+  }
+
+  if ((*bottleneck > 32000) && (*bottleneck < 38000)) {
+    *bottleneck = 32000;
+  } else if ((*bottleneck > 45000) && (*bottleneck < 50000)) {
+    *bottleneck = 45000;
+  } else if (*bottleneck > 56000) {
+    *bottleneck = 56000;
+  }
+  return 0;
+}
+
+
+/******************************************************************************
+ * WebRtcIsac_SetMaxPayloadSize(...)
+ *
+ * This function sets a limit for the maximum payload size of iSAC. The same
+ * value is used both for 30 and 60 ms packets. If the encoder sampling rate
+ * is 16 kHz the maximum payload size is between 120 and 400 bytes. If the
+ * encoder sampling rate is 32 kHz the maximum payload size is between 120
+ * and 600 bytes.
+ *
+ * ---------------
+ * IMPORTANT NOTES
+ * ---------------
+ * The size of a packet is limited to the minimum of 'max-payload-size' and
+ * 'max-rate.' For instance, let's assume the max-payload-size is set to
+ * 170 bytes, and max-rate is set to 40 kbps. Note that a limit of 40 kbps
+ * translates to 150 bytes for 30ms frame-size & 300 bytes for 60ms
+ * frame-size. Then a packet with a frame-size of 30 ms is limited to 150,
+ * i.e. min(170, 150), and a packet with 60 ms frame-size is limited to
+ * 170 bytes, i.e. min(170, 300).
+ *
+ * Input:
+ *        - ISAC_main_inst    : iSAC instance
+ *        - maxPayloadBytes   : maximum size of the payload in bytes
+ *                              valid values are between 100 and 400 bytes
+ *                              if encoder sampling rate is 16 kHz. For
+ *                              32 kHz encoder sampling rate valid values
+ *                              are between 100 and 600 bytes.
+ *
+ * Return value               : 0 if successful
+ *                             -1 if error happens
+ */
+int16_t WebRtcIsac_SetMaxPayloadSize(ISACStruct* ISAC_main_inst,
+                                     int16_t maxPayloadBytes) {
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+  int16_t status = 0;
+
+  /* Check if encoder initiated */
+  if ((instISAC->initFlag & BIT_MASK_ENC_INIT) !=
+      BIT_MASK_ENC_INIT) {
+    instISAC->errorCode = ISAC_ENCODER_NOT_INITIATED;
+    return -1;
+  }
+
+  if (instISAC->encoderSamplingRateKHz == kIsacSuperWideband) {
+    /* Sanity check. */
+    if (maxPayloadBytes < 120) {
+      /* 'maxRate' is out of valid range
+       * set to the acceptable value and return -1. */
+      maxPayloadBytes = 120;
+      status = -1;
+    }
+
+    /* sanity check */
+    if (maxPayloadBytes > STREAM_SIZE_MAX) {
+      /* maxRate is out of valid range,
+       * set to the acceptable value and return -1. */
+      maxPayloadBytes = STREAM_SIZE_MAX;
+      status = -1;
+    }
+  } else {
+    if (maxPayloadBytes < 120) {
+      /* Max payload-size is out of valid range
+       * set to the acceptable value and return -1. */
+      maxPayloadBytes = 120;
+      status = -1;
+    }
+    if (maxPayloadBytes > STREAM_SIZE_MAX_60) {
+      /* Max payload-size is out of valid range
+       * set to the acceptable value and return -1. */
+      maxPayloadBytes = STREAM_SIZE_MAX_60;
+      status = -1;
+    }
+  }
+  instISAC->maxPayloadSizeBytes = maxPayloadBytes;
+  UpdatePayloadSizeLimit(instISAC);
+  return status;
+}
+
+
+/******************************************************************************
+ * WebRtcIsac_SetMaxRate(...)
+ *
+ * This function sets the maximum rate which the codec may not exceed for
+ * any signal packet. The maximum rate is defined and payload-size per
+ * frame-size in bits per second.
+ *
+ * The codec has a maximum rate of 53400 bits per second (200 bytes per 30
+ * ms) if the encoder sampling rate is 16kHz, and 160 kbps (600 bytes/30 ms)
+ * if the encoder sampling rate is 32 kHz.
+ *
+ * It is possible to set a maximum rate between 32000 and 53400 bits/sec
+ * in wideband mode, and 32000 to 160000 bits/sec in super-wideband mode.
+ *
+ * ---------------
+ * IMPORTANT NOTES
+ * ---------------
+ * The size of a packet is limited to the minimum of 'max-payload-size' and
+ * 'max-rate.' For instance, let's assume the max-payload-size is set to
+ * 170 bytes, and max-rate is set to 40 kbps. Note that a limit of 40 kbps
+ * translates to 150 bytes for 30ms frame-size & 300 bytes for 60ms
+ * frame-size. Then a packet with a frame-size of 30 ms is limited to 150,
+ * i.e. min(170, 150), and a packet with 60 ms frame-size is limited to
+ * 170 bytes, min(170, 300).
+ *
+ * Input:
+ *        - ISAC_main_inst    : iSAC instance
+ *        - maxRate           : maximum rate in bits per second,
+ *                              valid values are 32000 to 53400 bits/sec in
+ *                              wideband mode, and 32000 to 160000 bits/sec in
+ *                              super-wideband mode.
+ *
+ * Return value               : 0 if successful
+ *                             -1 if error happens
+ */
+int16_t WebRtcIsac_SetMaxRate(ISACStruct* ISAC_main_inst,
+                              int32_t maxRate) {
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+  int16_t maxRateInBytesPer30Ms;
+  int16_t status = 0;
+
+  /* check if encoder initiated */
+  if ((instISAC->initFlag & BIT_MASK_ENC_INIT) != BIT_MASK_ENC_INIT) {
+    instISAC->errorCode = ISAC_ENCODER_NOT_INITIATED;
+    return -1;
+  }
+  /* Calculate maximum number of bytes per 30 msec packets for the
+     given maximum rate. Multiply with 30/1000 to get number of
+     bits per 30 ms, divide by 8 to get number of bytes per 30 ms:
+     maxRateInBytes = floor((maxRate * 30/1000) / 8); */
+  maxRateInBytesPer30Ms = (int16_t)(maxRate * 3 / 800);
+
+  if (instISAC->encoderSamplingRateKHz == kIsacWideband) {
+    if (maxRate < 32000) {
+      /* 'maxRate' is out of valid range.
+       * Set to the acceptable value and return -1. */
+      maxRateInBytesPer30Ms = 120;
+      status = -1;
+    }
+
+    if (maxRate > 53400) {
+      /* 'maxRate' is out of valid range.
+       * Set to the acceptable value and return -1. */
+      maxRateInBytesPer30Ms = 200;
+      status = -1;
+    }
+  } else {
+    if (maxRateInBytesPer30Ms < 120) {
+      /* 'maxRate' is out of valid range
+       * Set to the acceptable value and return -1. */
+      maxRateInBytesPer30Ms = 120;
+      status = -1;
+    }
+
+    if (maxRateInBytesPer30Ms > STREAM_SIZE_MAX) {
+      /* 'maxRate' is out of valid range.
+       * Set to the acceptable value and return -1. */
+      maxRateInBytesPer30Ms = STREAM_SIZE_MAX;
+      status = -1;
+    }
+  }
+  instISAC->maxRateBytesPer30Ms = maxRateInBytesPer30Ms;
+  UpdatePayloadSizeLimit(instISAC);
+  return status;
+}
+
+
+/****************************************************************************
+ * WebRtcIsac_GetRedPayload(...)
+ *
+ * This function populates "encoded" with the redundant payload of the recently
+ * encodedframe. This function has to be called once that WebRtcIsac_Encode(...)
+ * returns a positive value. Regardless of the frame-size this function will
+ * be called only once after encoding is completed. The bit-stream is
+ * targeted for 16000 bit/sec.
+ *
+ * Input:
+ *        - ISAC_main_inst    : iSAC struct
+ *
+ * Output:
+ *        - encoded           : the encoded data vector
+ *
+ *
+ * Return value               : >0 - Length (in bytes) of coded data
+ *                            : -1 - Error
+ */
+int16_t WebRtcIsac_GetRedPayload(ISACStruct* ISAC_main_inst,
+                                 uint8_t* encoded) {
+  Bitstr iSACBitStreamInst;
+  int16_t streamLenLB;
+  int16_t streamLenUB;
+  int16_t streamLen;
+  int16_t totalLenUB;
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+#ifndef WEBRTC_ARCH_BIG_ENDIAN
+  int k;
+#endif
+
+  if ((instISAC->initFlag & BIT_MASK_ENC_INIT) !=
+      BIT_MASK_ENC_INIT) {
+    instISAC->errorCode = ISAC_ENCODER_NOT_INITIATED;
+  }
+
+  WebRtcIsac_ResetBitstream(&(iSACBitStreamInst));
+
+  streamLenLB = WebRtcIsac_EncodeStoredDataLb(
+                  &instISAC->instLB.ISACencLB_obj.SaveEnc_obj,
+                  &iSACBitStreamInst,
+                  instISAC->instLB.ISACencLB_obj.lastBWIdx,
+                  RCU_TRANSCODING_SCALE);
+  if (streamLenLB < 0) {
+    return -1;
+  }
+
+  /* convert from bytes to int16_t. */
+  memcpy(encoded, iSACBitStreamInst.stream, streamLenLB);
+  streamLen = streamLenLB;
+  if (instISAC->bandwidthKHz == isac8kHz) {
+    return streamLenLB;
+  }
+
+  streamLenUB = WebRtcIsac_GetRedPayloadUb(
+                  &instISAC->instUB.ISACencUB_obj.SaveEnc_obj,
+                  &iSACBitStreamInst, instISAC->bandwidthKHz);
+  if (streamLenUB < 0) {
+    /* An error has happened but this is not the error due to a
+     * bit-stream larger than the limit. */
+    return -1;
+  }
+
+  /* We have one byte to write the total length of the upper-band.
+   * The length includes the bit-stream length, check-sum and the
+   * single byte where the length is written to. This is according to
+   * iSAC wideband and how the "garbage" is dealt. */
+  totalLenUB = streamLenUB + 1 + LEN_CHECK_SUM_WORD8;
+  if (totalLenUB > 255) {
+    streamLenUB = 0;
+  }
+
+  /* Generate CRC if required. */
+  if ((instISAC->bandwidthKHz != isac8kHz) &&
+      (streamLenUB > 0)) {
+    uint32_t crc;
+    streamLen += totalLenUB;
+    encoded[streamLenLB] = (uint8_t)totalLenUB;
+    memcpy(&encoded[streamLenLB + 1], iSACBitStreamInst.stream,
+           streamLenUB);
+
+    WebRtcIsac_GetCrc((int16_t*)(&(encoded[streamLenLB + 1])),
+                      streamLenUB, &crc);
+#ifndef WEBRTC_ARCH_BIG_ENDIAN
+    for (k = 0; k < LEN_CHECK_SUM_WORD8; k++) {
+      encoded[streamLen - LEN_CHECK_SUM_WORD8 + k] =
+        (uint8_t)((crc >> (24 - k * 8)) & 0xFF);
+    }
+#else
+    memcpy(&encoded[streamLenLB + streamLenUB + 1], &crc,
+           LEN_CHECK_SUM_WORD8);
+#endif
+  }
+  return streamLen;
+}
+
+
+/****************************************************************************
+ * WebRtcIsac_version(...)
+ *
+ * This function returns the version number.
+ *
+ * Output:
+ *        - version      : Pointer to character string
+ *
+ */
+void WebRtcIsac_version(char* version) {
+  strcpy(version, "4.3.0");
+}
+
+
+/******************************************************************************
+ * WebRtcIsac_SetEncSampRate()
+ * This function sets the sampling rate of the encoder. Initialization of the
+ * encoder WILL NOT overwrite the sampling rate of the encoder. The default
+ * value is 16 kHz which is set when the instance is created. The encoding-mode
+ * and the bottleneck remain unchanged by this call, however, the maximum rate
+ * and maximum payload-size will be reset to their default values.
+ *
+ * Input:
+ *        - ISAC_main_inst    : iSAC instance
+ *        - sample_rate_hz    : sampling rate in Hertz, valid values are 16000
+ *                              and 32000.
+ *
+ * Return value               : 0 if successful
+ *                             -1 if failed.
+ */
+int16_t WebRtcIsac_SetEncSampRate(ISACStruct* ISAC_main_inst,
+                                  uint16_t sample_rate_hz) {
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+  enum IsacSamplingRate encoder_operational_rate;
+
+  if ((sample_rate_hz != 16000) && (sample_rate_hz != 32000)) {
+    /* Sampling Frequency is not supported. */
+    instISAC->errorCode = ISAC_UNSUPPORTED_SAMPLING_FREQUENCY;
+    return -1;
+  }
+  if (sample_rate_hz == 16000) {
+    encoder_operational_rate = kIsacWideband;
+  } else {
+    encoder_operational_rate = kIsacSuperWideband;
+  }
+
+  if ((instISAC->initFlag & BIT_MASK_ENC_INIT) !=
+      BIT_MASK_ENC_INIT) {
+    if (encoder_operational_rate == kIsacWideband) {
+      instISAC->bandwidthKHz = isac8kHz;
+    } else {
+      instISAC->bandwidthKHz = isac16kHz;
+    }
+  } else {
+    ISACUBStruct* instUB = &(instISAC->instUB);
+    ISACLBStruct* instLB = &(instISAC->instLB);
+    int32_t bottleneck = instISAC->bottleneck;
+    int16_t codingMode = instISAC->codingMode;
+    int16_t frameSizeMs = instLB->ISACencLB_obj.new_framelength /
+        (FS / 1000);
+
+    if ((encoder_operational_rate == kIsacWideband) &&
+        (instISAC->encoderSamplingRateKHz == kIsacSuperWideband)) {
+      /* Changing from super-wideband to wideband.
+       * we don't need to re-initialize the encoder of the lower-band. */
+      instISAC->bandwidthKHz = isac8kHz;
+      if (codingMode == 1) {
+        ControlLb(instLB,
+                  (bottleneck > 32000) ? 32000 : bottleneck, FRAMESIZE);
+      }
+      instISAC->maxPayloadSizeBytes = STREAM_SIZE_MAX_60;
+      instISAC->maxRateBytesPer30Ms = STREAM_SIZE_MAX_30;
+    } else if ((encoder_operational_rate == kIsacSuperWideband) &&
+               (instISAC->encoderSamplingRateKHz == kIsacWideband)) {
+      double bottleneckLB = 0;
+      double bottleneckUB = 0;
+      if (codingMode == 1) {
+        WebRtcIsac_RateAllocation(bottleneck, &bottleneckLB, &bottleneckUB,
+                                  &(instISAC->bandwidthKHz));
+      }
+
+      instISAC->bandwidthKHz = isac16kHz;
+      instISAC->maxPayloadSizeBytes = STREAM_SIZE_MAX;
+      instISAC->maxRateBytesPer30Ms = STREAM_SIZE_MAX;
+
+      EncoderInitLb(instLB, codingMode, encoder_operational_rate);
+      EncoderInitUb(instUB, instISAC->bandwidthKHz);
+
+      memset(instISAC->analysisFBState1, 0,
+             FB_STATE_SIZE_WORD32 * sizeof(int32_t));
+      memset(instISAC->analysisFBState2, 0,
+             FB_STATE_SIZE_WORD32 * sizeof(int32_t));
+
+      if (codingMode == 1) {
+        instISAC->bottleneck = bottleneck;
+        ControlLb(instLB, bottleneckLB,
+                  (instISAC->bandwidthKHz == isac8kHz) ? frameSizeMs:FRAMESIZE);
+        if (instISAC->bandwidthKHz > isac8kHz) {
+          ControlUb(instUB, bottleneckUB);
+        }
+      } else {
+        instLB->ISACencLB_obj.enforceFrameSize = 0;
+        instLB->ISACencLB_obj.new_framelength = FRAMESAMPLES;
+      }
+    }
+  }
+  instISAC->encoderSamplingRateKHz = encoder_operational_rate;
+  instISAC->in_sample_rate_hz = sample_rate_hz;
+  return 0;
+}
+
+
+/******************************************************************************
+ * WebRtcIsac_SetDecSampRate()
+ * This function sets the sampling rate of the decoder. Initialization of the
+ * decoder WILL NOT overwrite the sampling rate of the encoder. The default
+ * value is 16 kHz which is set when the instance is created.
+ *
+ * Input:
+ *        - ISAC_main_inst    : iSAC instance
+ *        - sample_rate_hz    : sampling rate in Hertz, valid values are 16000
+ *                              and 32000.
+ *
+ * Return value               : 0 if successful
+ *                             -1 if failed.
+ */
+int16_t WebRtcIsac_SetDecSampRate(ISACStruct* ISAC_main_inst,
+                                  uint16_t sample_rate_hz) {
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+  enum IsacSamplingRate decoder_operational_rate;
+
+  if (sample_rate_hz == 16000) {
+    decoder_operational_rate = kIsacWideband;
+  } else if (sample_rate_hz == 32000) {
+    decoder_operational_rate = kIsacSuperWideband;
+  } else {
+    /* Sampling Frequency is not supported. */
+    instISAC->errorCode = ISAC_UNSUPPORTED_SAMPLING_FREQUENCY;
+    return -1;
+  }
+
+  if ((instISAC->decoderSamplingRateKHz == kIsacWideband) &&
+        (decoder_operational_rate == kIsacSuperWideband)) {
+      /* Switching from wideband to super-wideband at the decoder
+       * we need to reset the filter-bank and initialize upper-band decoder. */
+      memset(instISAC->synthesisFBState1, 0,
+             FB_STATE_SIZE_WORD32 * sizeof(int32_t));
+      memset(instISAC->synthesisFBState2, 0,
+             FB_STATE_SIZE_WORD32 * sizeof(int32_t));
+
+      DecoderInitUb(&instISAC->instUB);
+  }
+  instISAC->decoderSamplingRateKHz = decoder_operational_rate;
+  return 0;
+}
+
+
+/******************************************************************************
+ * WebRtcIsac_EncSampRate()
+ *
+ * Input:
+ *        - ISAC_main_inst    : iSAC instance
+ *
+ * Return value               : sampling rate in Hertz. The input to encoder
+ *                              is expected to be sampled in this rate.
+ *
+ */
+uint16_t WebRtcIsac_EncSampRate(ISACStruct* ISAC_main_inst) {
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+  return instISAC->in_sample_rate_hz;
+}
+
+
+/******************************************************************************
+ * WebRtcIsac_DecSampRate()
+ * Return the sampling rate of the decoded audio.
+ *
+ * Input:
+ *        - ISAC_main_inst    : iSAC instance
+ *
+ * Return value               : sampling rate in Hertz. Decoder output is
+ *                              sampled at this rate.
+ *
+ */
+uint16_t WebRtcIsac_DecSampRate(ISACStruct* ISAC_main_inst) {
+  ISACMainStruct* instISAC = (ISACMainStruct*)ISAC_main_inst;
+  return instISAC->decoderSamplingRateKHz == kIsacWideband ? 16000 : 32000;
+}
+
+void WebRtcIsac_GetBandwidthInfo(ISACStruct* inst,
+                                 IsacBandwidthInfo* bwinfo) {
+  ISACMainStruct* instISAC = (ISACMainStruct*)inst;
+  assert(instISAC->initFlag & BIT_MASK_DEC_INIT);
+  WebRtcIsacBw_GetBandwidthInfo(&instISAC->bwestimator_obj,
+                                instISAC->decoderSamplingRateKHz, bwinfo);
+}
+
+void WebRtcIsac_SetBandwidthInfo(ISACStruct* inst,
+                                 const IsacBandwidthInfo* bwinfo) {
+  ISACMainStruct* instISAC = (ISACMainStruct*)inst;
+  assert(instISAC->initFlag & BIT_MASK_ENC_INIT);
+  WebRtcIsacBw_SetBandwidthInfo(&instISAC->bwestimator_obj, bwinfo);
+}
+
+void WebRtcIsac_SetEncSampRateInDecoder(ISACStruct* inst,
+                                        int sample_rate_hz) {
+  ISACMainStruct* instISAC = (ISACMainStruct*)inst;
+  assert(instISAC->initFlag & BIT_MASK_DEC_INIT);
+  assert(!(instISAC->initFlag & BIT_MASK_ENC_INIT));
+  assert(sample_rate_hz == 16000 || sample_rate_hz == 32000);
+  instISAC->encoderSamplingRateKHz = sample_rate_hz / 1000;
+}
diff --git a/webrtc/modules/audio_coding/codecs/isac/main/source/isac_float_type.h b/webrtc/modules/audio_coding/codecs/isac/main/source/isac_float_type.h
new file mode 100644
index 0000000..e150d39
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/main/source/isac_float_type.h
@@ -0,0 +1,117 @@
+/*
+ *  Copyright (c) 2015 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.
+ */
+
+#ifndef WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_ISAC_FLOAT_TYPE_H_
+#define WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_ISAC_FLOAT_TYPE_H_
+
+#include "webrtc/modules/audio_coding/codecs/isac/main/include/isac.h"
+
+namespace webrtc {
+
+struct IsacFloat {
+  using instance_type = ISACStruct;
+  static const bool has_swb = true;
+  static inline int16_t Control(instance_type* inst,
+                                int32_t rate,
+                                int framesize) {
+    return WebRtcIsac_Control(inst, rate, framesize);
+  }
+  static inline int16_t ControlBwe(instance_type* inst,
+                                   int32_t rate_bps,
+                                   int frame_size_ms,
+                                   int16_t enforce_frame_size) {
+    return WebRtcIsac_ControlBwe(inst, rate_bps, frame_size_ms,
+                                 enforce_frame_size);
+  }
+  static inline int16_t Create(instance_type** inst) {
+    return WebRtcIsac_Create(inst);
+  }
+  static inline int DecodeInternal(instance_type* inst,
+                                   const uint8_t* encoded,
+                                   size_t len,
+                                   int16_t* decoded,
+                                   int16_t* speech_type) {
+    return WebRtcIsac_Decode(inst, encoded, len, decoded, speech_type);
+  }
+  static inline size_t DecodePlc(instance_type* inst,
+                                 int16_t* decoded,
+                                 size_t num_lost_frames) {
+    return WebRtcIsac_DecodePlc(inst, decoded, num_lost_frames);
+  }
+
+  static inline void DecoderInit(instance_type* inst) {
+    WebRtcIsac_DecoderInit(inst);
+  }
+  static inline int Encode(instance_type* inst,
+                           const int16_t* speech_in,
+                           uint8_t* encoded) {
+    return WebRtcIsac_Encode(inst, speech_in, encoded);
+  }
+  static inline int16_t EncoderInit(instance_type* inst, int16_t coding_mode) {
+    return WebRtcIsac_EncoderInit(inst, coding_mode);
+  }
+  static inline uint16_t EncSampRate(instance_type* inst) {
+    return WebRtcIsac_EncSampRate(inst);
+  }
+
+  static inline int16_t Free(instance_type* inst) {
+    return WebRtcIsac_Free(inst);
+  }
+  static inline void GetBandwidthInfo(instance_type* inst,
+                                      IsacBandwidthInfo* bwinfo) {
+    WebRtcIsac_GetBandwidthInfo(inst, bwinfo);
+  }
+  static inline int16_t GetErrorCode(instance_type* inst) {
+    return WebRtcIsac_GetErrorCode(inst);
+  }
+
+  static inline int16_t GetNewFrameLen(instance_type* inst) {
+    return WebRtcIsac_GetNewFrameLen(inst);
+  }
+  static inline void SetBandwidthInfo(instance_type* inst,
+                                      const IsacBandwidthInfo* bwinfo) {
+    WebRtcIsac_SetBandwidthInfo(inst, bwinfo);
+  }
+  static inline int16_t SetDecSampRate(instance_type* inst,
+                                       uint16_t sample_rate_hz) {
+    return WebRtcIsac_SetDecSampRate(inst, sample_rate_hz);
+  }
+  static inline int16_t SetEncSampRate(instance_type* inst,
+                                       uint16_t sample_rate_hz) {
+    return WebRtcIsac_SetEncSampRate(inst, sample_rate_hz);
+  }
+  static inline void SetEncSampRateInDecoder(instance_type* inst,
+                                             uint16_t sample_rate_hz) {
+    WebRtcIsac_SetEncSampRateInDecoder(inst, sample_rate_hz);
+  }
+  static inline void SetInitialBweBottleneck(instance_type* inst,
+                                             int bottleneck_bits_per_second) {
+    WebRtcIsac_SetInitialBweBottleneck(inst, bottleneck_bits_per_second);
+  }
+  static inline int16_t UpdateBwEstimate(instance_type* inst,
+                                         const uint8_t* encoded,
+                                         size_t packet_size,
+                                         uint16_t rtp_seq_number,
+                                         uint32_t send_ts,
+                                         uint32_t arr_ts) {
+    return WebRtcIsac_UpdateBwEstimate(inst, encoded, packet_size,
+                                       rtp_seq_number, send_ts, arr_ts);
+  }
+  static inline int16_t SetMaxPayloadSize(instance_type* inst,
+                                          int16_t max_payload_size_bytes) {
+    return WebRtcIsac_SetMaxPayloadSize(inst, max_payload_size_bytes);
+  }
+  static inline int16_t SetMaxRate(instance_type* inst, int32_t max_bit_rate) {
+    return WebRtcIsac_SetMaxRate(inst, max_bit_rate);
+  }
+};
+
+}  // namespace webrtc
+#endif  // WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_ISAC_FLOAT_TYPE_H_
diff --git a/webrtc/modules/audio_coding/codecs/isac/main/source/lattice.c b/webrtc/modules/audio_coding/codecs/isac/main/source/lattice.c
new file mode 100644
index 0000000..eabe708
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/main/source/lattice.c
@@ -0,0 +1,218 @@
+/*
+ *  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.
+ */
+
+/*
+ * lattice.c
+ *
+ * contains the normalized lattice filter routines (MA and AR) for iSAC codec
+ *
+ */
+#include "settings.h"
+#include "codec.h"
+
+#include <math.h>
+#include <memory.h>
+#include <string.h>
+#ifdef WEBRTC_ANDROID
+#include <stdlib.h>
+#endif
+
+/* filter the signal using normalized lattice filter */
+/* MA filter */
+void WebRtcIsac_NormLatticeFilterMa(int orderCoef,
+                                     float *stateF,
+                                     float *stateG,
+                                     float *lat_in,
+                                     double *filtcoeflo,
+                                     double *lat_out)
+{
+  int n,k,i,u,temp1;
+  int ord_1 = orderCoef+1;
+  float sth[MAX_AR_MODEL_ORDER];
+  float cth[MAX_AR_MODEL_ORDER];
+  float inv_cth[MAX_AR_MODEL_ORDER];
+  double a[MAX_AR_MODEL_ORDER+1];
+  float f[MAX_AR_MODEL_ORDER+1][HALF_SUBFRAMELEN], g[MAX_AR_MODEL_ORDER+1][HALF_SUBFRAMELEN];
+  float gain1;
+
+  for (u=0;u<SUBFRAMES;u++)
+  {
+    /* set the Direct Form coefficients */
+    temp1 = u*ord_1;
+    a[0] = 1;
+    memcpy(a+1, filtcoeflo+temp1+1, sizeof(double) * (ord_1-1));
+
+    /* compute lattice filter coefficients */
+    WebRtcIsac_Dir2Lat(a,orderCoef,sth,cth);
+
+    /* compute the gain */
+    gain1 = (float)filtcoeflo[temp1];
+    for (k=0;k<orderCoef;k++)
+    {
+      gain1 *= cth[k];
+      inv_cth[k] = 1/cth[k];
+    }
+
+    /* normalized lattice filter */
+    /*****************************/
+
+    /* initial conditions */
+    for (i=0;i<HALF_SUBFRAMELEN;i++)
+    {
+      f[0][i] = lat_in[i + u * HALF_SUBFRAMELEN];
+      g[0][i] = lat_in[i + u * HALF_SUBFRAMELEN];
+    }
+
+    /* get the state of f&g for the first input, for all orders */
+    for (i=1;i<ord_1;i++)
+    {
+      f[i][0] = inv_cth[i-1]*(f[i-1][0] + sth[i-1]*stateG[i-1]);
+      g[i][0] = cth[i-1]*stateG[i-1] + sth[i-1]* f[i][0];
+    }
+
+    /* filtering */
+    for(k=0;k<orderCoef;k++)
+    {
+      for(n=0;n<(HALF_SUBFRAMELEN-1);n++)
+      {
+        f[k+1][n+1] = inv_cth[k]*(f[k][n+1] + sth[k]*g[k][n]);
+        g[k+1][n+1] = cth[k]*g[k][n] + sth[k]* f[k+1][n+1];
+      }
+    }
+
+    for(n=0;n<HALF_SUBFRAMELEN;n++)
+    {
+      lat_out[n + u * HALF_SUBFRAMELEN] = gain1 * f[orderCoef][n];
+    }
+
+    /* save the states */
+    for (i=0;i<ord_1;i++)
+    {
+      stateF[i] = f[i][HALF_SUBFRAMELEN-1];
+      stateG[i] = g[i][HALF_SUBFRAMELEN-1];
+    }
+    /* process next frame */
+  }
+
+  return;
+}
+
+
+/*///////////////////AR filter ///////////////////////////////*/
+/* filter the signal using normalized lattice filter */
+void WebRtcIsac_NormLatticeFilterAr(int orderCoef,
+                                     float *stateF,
+                                     float *stateG,
+                                     double *lat_in,
+                                     double *lo_filt_coef,
+                                     float *lat_out)
+{
+  int n,k,i,u,temp1;
+  int ord_1 = orderCoef+1;
+  float sth[MAX_AR_MODEL_ORDER];
+  float cth[MAX_AR_MODEL_ORDER];
+  double a[MAX_AR_MODEL_ORDER+1];
+  float ARf[MAX_AR_MODEL_ORDER+1][HALF_SUBFRAMELEN], ARg[MAX_AR_MODEL_ORDER+1][HALF_SUBFRAMELEN];
+  float gain1,inv_gain1;
+
+  for (u=0;u<SUBFRAMES;u++)
+  {
+    /* set the denominator and numerator of the Direct Form */
+    temp1 = u*ord_1;
+    a[0] = 1;
+
+    memcpy(a+1, lo_filt_coef+temp1+1, sizeof(double) * (ord_1-1));
+
+    WebRtcIsac_Dir2Lat(a,orderCoef,sth,cth);
+
+    gain1 = (float)lo_filt_coef[temp1];
+    for (k=0;k<orderCoef;k++)
+    {
+      gain1 = cth[k]*gain1;
+    }
+
+    /* initial conditions */
+    inv_gain1 = 1/gain1;
+    for (i=0;i<HALF_SUBFRAMELEN;i++)
+    {
+      ARf[orderCoef][i] = (float)lat_in[i + u * HALF_SUBFRAMELEN]*inv_gain1;
+    }
+
+
+    for (i=orderCoef-1;i>=0;i--) //get the state of f&g for the first input, for all orders
+    {
+      ARf[i][0] = cth[i]*ARf[i+1][0] - sth[i]*stateG[i];
+      ARg[i+1][0] = sth[i]*ARf[i+1][0] + cth[i]* stateG[i];
+    }
+    ARg[0][0] = ARf[0][0];
+
+    for(n=0;n<(HALF_SUBFRAMELEN-1);n++)
+    {
+      for(k=orderCoef-1;k>=0;k--)
+      {
+        ARf[k][n+1] = cth[k]*ARf[k+1][n+1] - sth[k]*ARg[k][n];
+        ARg[k+1][n+1] = sth[k]*ARf[k+1][n+1] + cth[k]* ARg[k][n];
+      }
+      ARg[0][n+1] = ARf[0][n+1];
+    }
+
+    memcpy(lat_out+u * HALF_SUBFRAMELEN, &(ARf[0][0]), sizeof(float) * HALF_SUBFRAMELEN);
+
+    /* cannot use memcpy in the following */
+    for (i=0;i<ord_1;i++)
+    {
+      stateF[i] = ARf[i][HALF_SUBFRAMELEN-1];
+      stateG[i] = ARg[i][HALF_SUBFRAMELEN-1];
+    }
+
+  }
+
+  return;
+}
+
+
+/* compute the reflection coefficients using the step-down procedure*/
+/* converts the direct form parameters to lattice form.*/
+/* a and b are vectors which contain the direct form coefficients,
+   according to
+   A(z) = a(1) + a(2)*z + a(3)*z^2 + ... + a(M+1)*z^M
+   B(z) = b(1) + b(2)*z + b(3)*z^2 + ... + b(M+1)*z^M
+*/
+
+void WebRtcIsac_Dir2Lat(double *a,
+                        int orderCoef,
+                        float *sth,
+                        float *cth)
+{
+  int m, k;
+  float tmp[MAX_AR_MODEL_ORDER];
+  float tmp_inv, cth2;
+
+  sth[orderCoef-1] = (float)a[orderCoef];
+  cth2 = 1.0f - sth[orderCoef-1] * sth[orderCoef-1];
+  cth[orderCoef-1] = (float)sqrt(cth2);
+  for (m=orderCoef-1; m>0; m--)
+  {
+    tmp_inv = 1.0f / cth2;
+    for (k=1; k<=m; k++)
+    {
+      tmp[k] = ((float)a[k] - sth[m] * (float)a[m-k+1]) * tmp_inv;
+    }
+
+    for (k=1; k<m; k++)
+    {
+      a[k] = tmp[k];
+    }
+
+    sth[m-1] = tmp[m];
+    cth2 = 1 - sth[m-1] * sth[m-1];
+    cth[m-1] = (float)sqrt(cth2);
+  }
+}
diff --git a/webrtc/modules/audio_coding/codecs/isac/main/source/transform.c b/webrtc/modules/audio_coding/codecs/isac/main/source/transform.c
new file mode 100644
index 0000000..8992897
--- /dev/null
+++ b/webrtc/modules/audio_coding/codecs/isac/main/source/transform.c
@@ -0,0 +1,125 @@
+/*
+ *  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.
+ */
+
+#include "settings.h"
+#include "fft.h"
+#include "codec.h"
+#include "os_specific_inline.h"
+#include <math.h>
+
+void WebRtcIsac_InitTransform(TransformTables* tables) {
+  int k;
+  double fact, phase;
+
+  fact = PI / (FRAMESAMPLES_HALF);
+  phase = 0.0;
+  for (k = 0; k < FRAMESAMPLES_HALF; k++) {
+    tables->costab1[k] = cos(phase);
+    tables->sintab1[k] = sin(phase);
+    phase += fact;
+  }
+
+  fact = PI * ((double) (FRAMESAMPLES_HALF - 1)) / ((double) FRAMESAMPLES_HALF);
+  phase = 0.5 * fact;
+  for (k = 0; k < FRAMESAMPLES_QUARTER; k++) {
+    tables->costab2[k] = cos(phase);
+    tables->sintab2[k] = sin(phase);
+    phase += fact;
+  }
+}
+
+void WebRtcIsac_Time2Spec(const TransformTables* tables,
+                          double* inre1,
+                          double* inre2,
+                          int16_t* outreQ7,
+                          int16_t* outimQ7,
+                          FFTstr* fftstr_obj) {
+  int k;
+  int dims[1];
+  double tmp1r, tmp1i, xr, xi, yr, yi, fact;
+  double tmpre[FRAMESAMPLES_HALF], tmpim[FRAMESAMPLES_HALF];
+
+
+  dims[0] = FRAMESAMPLES_HALF;
+
+
+  /* Multiply with complex exponentials and combine into one complex vector */
+  fact = 0.5 / sqrt(FRAMESAMPLES_HALF);
+  for (k = 0; k < FRAMESAMPLES_HALF; k++) {
+    tmp1r = tables->costab1[k];
+    tmp1i = tables->sintab1[k];
+    tmpre[k] = (inre1[k] * tmp1r + inre2[k] * tmp1i) * fact;
+    tmpim[k] = (inre2[k] * tmp1r - inre1[k] * tmp1i) * fact;
+  }
+
+
+  /* Get DFT */
+  WebRtcIsac_Fftns(1, dims, tmpre, tmpim, -1, 1.0, fftstr_obj);
+
+  /* Use symmetry to separate into two complex vectors and center frames in time around zero */
+  for (k = 0; k < FRAMESAMPLES_QUARTER; k++) {
+    xr = tmpre[k] + tmpre[FRAMESAMPLES_HALF - 1 - k];
+    yi = -tmpre[k] + tmpre[FRAMESAMPLES_HALF - 1 - k];
+    xi = tmpim[k] - tmpim[FRAMESAMPLES_HALF - 1 - k];
+    yr = tmpim[k] + tmpim[FRAMESAMPLES_HALF - 1 - k];
+
+    tmp1r = tables->costab2[k];
+    tmp1i = tables->sintab2[k];
+    outreQ7[k] = (int16_t)WebRtcIsac_lrint((xr * tmp1r - xi * tmp1i) * 128.0);
+    outimQ7[k] = (int16_t)WebRtcIsac_lrint((xr * tmp1i + xi * tmp1r) * 128.0);
+    outreQ7[FRAMESAMPLES_HALF - 1 - k] = (int16_t)WebRtcIsac_lrint((-yr * tmp1i - yi * tmp1r) * 128.0);
+    outimQ7[FRAMESAMPLES_HALF - 1 - k] = (int16_t)WebRtcIsac_lrint((-yr * tmp1r + yi * tmp1i) * 128.0);
+  }
+}
+
+void WebRtcIsac_Spec2time(const TransformTables* tables,
+                          double* inre,
+                          double* inim,
+                          double* outre1,
+                          double* outre2,
+                          FFTstr* fftstr_obj) {
+  int k;
+  double tmp1r, tmp1i, xr, xi, yr, yi, fact;
+
+  int dims;
+
+  dims = FRAMESAMPLES_HALF;
+
+  for (k = 0; k < FRAMESAMPLES_QUARTER; k++) {
+    /* Move zero in time to beginning of frames */
+    tmp1r = tables->costab2[k];
+    tmp1i = tables->sintab2[k];
+    xr = inre[k] * tmp1r + inim[k] * tmp1i;
+    xi = inim[k] * tmp1r - inre[k] * tmp1i;
+    yr = -inim[FRAMESAMPLES_HALF - 1 - k] * tmp1r - inre[FRAMESAMPLES_HALF - 1 - k] * tmp1i;
+    yi = -inre[FRAMESAMPLES_HALF - 1 - k] * tmp1r + inim[FRAMESAMPLES_HALF - 1 - k] * tmp1i;
+
+    /* Combine into one vector,  z = x + j * y */
+    outre1[k] = xr - yi;
+    outre1[FRAMESAMPLES_HALF - 1 - k] = xr + yi;
+    outre2[k] = xi + yr;
+    outre2[FRAMESAMPLES_HALF - 1 - k] = -xi + yr;
+  }
+
+
+  /* Get IDFT */
+  WebRtcIsac_Fftns(1, &dims, outre1, outre2, 1, FRAMESAMPLES_HALF, fftstr_obj);
+
+
+  /* Demodulate and separate */
+  fact = sqrt(FRAMESAMPLES_HALF);
+  for (k = 0; k < FRAMESAMPLES_HALF; k++) {
+    tmp1r = tables->costab1[k];
+    tmp1i = tables->sintab1[k];
+    xr = (outre1[k] * tmp1r - outre2[k] * tmp1i) * fact;
+    outre2[k] = (outre2[k] * tmp1r + outre1[k] * tmp1i) * fact;
+    outre1[k] = xr;
+  }
+}
diff --git a/webrtc/modules/audio_coding/meson.build b/webrtc/modules/audio_coding/meson.build
index 5975bfa..fb46df8 100644
--- a/webrtc/modules/audio_coding/meson.build
+++ b/webrtc/modules/audio_coding/meson.build
@@ -1,4 +1,4 @@
-audio_coding_sources = [
+webrtc_audio_coding_sources = [
   'codecs/isac/main/source/arith_routines.c',
   'codecs/isac/main/source/arith_routines_hist.c',
   'codecs/isac/main/source/arith_routines_logist.c',
@@ -18,16 +18,45 @@ audio_coding_sources = [
   'codecs/isac/main/source/pitch_gain_tables.c',
   'codecs/isac/main/source/pitch_lag_tables.c',
   'codecs/isac/main/source/spectrum_ar_model_tables.c',
+  'codecs/audio_decoder.cc',
+  'codecs/audio_encoder.cc',
+  'codecs/isac/main/source/audio_decoder_isac.cc',
+  'codecs/isac/main/source/audio_encoder_isac.cc',
+  'codecs/isac/main/source/bandwidth_estimator.c',
+  'codecs/isac/main/source/crc.c',
+  'codecs/isac/main/source/decode.c',
+  'codecs/isac/main/source/decode_bwe.c',
+  'codecs/isac/main/source/encode.c',
+  'codecs/isac/main/source/fft.c',
+  'codecs/isac/main/source/isac.c',
+  'codecs/isac/main/source/lattice.c',
+  'codecs/isac/main/source/transform.c',
 ]
 
-libaudio_coding = static_library('audio_coding',
-    audio_coding_sources,
-    dependencies: common_deps,
+libwebrtc_audio_coding = library('webrtc_audio_coding',
+    webrtc_audio_coding_sources,
+    dependencies: [base_dep, common_audio_dep] + common_deps,
     include_directories: webrtc_inc,
     c_args: common_cflags,
-    cpp_args: common_cxxflags
+    cpp_args: common_cxxflags,
+    soversion: soversion,
+    install: true
 )
 
-audio_coding_dep = declare_dependency(
-    link_with: libaudio_coding
+webrtc_audio_coding_dep = declare_dependency(
+    link_with: libwebrtc_audio_coding,
+    include_directories: webrtc_inc,
+    version: meson.project_version()
+)
+
+install_headers(['codecs/isac/bandwidth_info.h'],
+    subdir: 'webrtc_audio_processing/webrtc/modules/audio_coding/codecs/isac'
+)
+
+install_headers(['codecs/isac/main/source/settings.h'],
+    subdir: 'webrtc_audio_processing/webrtc/modules/audio_coding/codecs/isac/main/source'
+)
+
+install_headers(['codecs/isac/main/include/isac.h'],
+    subdir: 'webrtc_audio_processing/webrtc/modules/audio_coding/codecs/isac/main/include'
 )
diff --git a/webrtc/modules/audio_processing/meson.build b/webrtc/modules/audio_processing/meson.build
index 5ce87a1..34e23e0 100644
--- a/webrtc/modules/audio_processing/meson.build
+++ b/webrtc/modules/audio_processing/meson.build
@@ -109,7 +109,7 @@ install_headers(webrtc_audio_processing_include_headers,
 
 libwebrtc_audio_processing = library('webrtc_audio_processing',
     webrtc_audio_processing_sources,
-    dependencies: [base_dep, audio_coding_dep, system_wrappers_dep, common_audio_dep, audio_coding_dep, webrtc_dep] + common_deps,
+    dependencies: [base_dep, webrtc_audio_coding_dep, system_wrappers_dep, common_audio_dep, webrtc_dep] + common_deps,
     link_with: extra_libs,
     include_directories: webrtc_inc,
     c_args: common_cflags,