// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: config.proto

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "config.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/port.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)

namespace webrtc {
namespace audio_network_adaptor {
namespace config {
class FecController_ThresholdDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<FecController_Threshold> {
} _FecController_Threshold_default_instance_;
class FecControllerDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<FecController> {
} _FecController_default_instance_;
class FecControllerRplrBased_ThresholdDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<FecControllerRplrBased_Threshold> {
} _FecControllerRplrBased_Threshold_default_instance_;
class FecControllerRplrBasedDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<FecControllerRplrBased> {
} _FecControllerRplrBased_default_instance_;
class FrameLengthControllerDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<FrameLengthController> {
} _FrameLengthController_default_instance_;
class ChannelControllerDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<ChannelController> {
} _ChannelController_default_instance_;
class DtxControllerDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<DtxController> {
} _DtxController_default_instance_;
class BitrateControllerDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<BitrateController> {
} _BitrateController_default_instance_;
class Controller_ScoringPointDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Controller_ScoringPoint> {
} _Controller_ScoringPoint_default_instance_;
class ControllerDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Controller> {
  public:
  const ::webrtc::audio_network_adaptor::config::FecController* fec_controller_;
  const ::webrtc::audio_network_adaptor::config::FrameLengthController* frame_length_controller_;
  const ::webrtc::audio_network_adaptor::config::ChannelController* channel_controller_;
  const ::webrtc::audio_network_adaptor::config::DtxController* dtx_controller_;
  const ::webrtc::audio_network_adaptor::config::BitrateController* bitrate_controller_;
  const ::webrtc::audio_network_adaptor::config::FecControllerRplrBased* fec_controller_rplr_based_;
} _Controller_default_instance_;
class ControllerManagerDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<ControllerManager> {
} _ControllerManager_default_instance_;

namespace protobuf_config_2eproto {

PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::ParseTableField
    const TableStruct::entries[] = {
  {0, 0, 0, ::google::protobuf::internal::kInvalidMask, 0, 0},
};

PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::AuxillaryParseTableField
    const TableStruct::aux[] = {
  ::google::protobuf::internal::AuxillaryParseTableField(),
};
PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::ParseTable const
    TableStruct::schema[] = {
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
};


void TableStruct::Shutdown() {
  _FecController_Threshold_default_instance_.Shutdown();
  _FecController_default_instance_.Shutdown();
  _FecControllerRplrBased_Threshold_default_instance_.Shutdown();
  _FecControllerRplrBased_default_instance_.Shutdown();
  _FrameLengthController_default_instance_.Shutdown();
  _ChannelController_default_instance_.Shutdown();
  _DtxController_default_instance_.Shutdown();
  _BitrateController_default_instance_.Shutdown();
  _Controller_ScoringPoint_default_instance_.Shutdown();
  _Controller_default_instance_.Shutdown();
  _ControllerManager_default_instance_.Shutdown();
}

void TableStruct::InitDefaultsImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::google::protobuf::internal::InitProtobufDefaults();
  _FecController_Threshold_default_instance_.DefaultConstruct();
  _FecController_default_instance_.DefaultConstruct();
  _FecControllerRplrBased_Threshold_default_instance_.DefaultConstruct();
  _FecControllerRplrBased_default_instance_.DefaultConstruct();
  _FrameLengthController_default_instance_.DefaultConstruct();
  _ChannelController_default_instance_.DefaultConstruct();
  _DtxController_default_instance_.DefaultConstruct();
  _BitrateController_default_instance_.DefaultConstruct();
  _Controller_ScoringPoint_default_instance_.DefaultConstruct();
  _Controller_default_instance_.DefaultConstruct();
  _ControllerManager_default_instance_.DefaultConstruct();
  _FecController_default_instance_.get_mutable()->fec_enabling_threshold_ = const_cast< ::webrtc::audio_network_adaptor::config::FecController_Threshold*>(
      ::webrtc::audio_network_adaptor::config::FecController_Threshold::internal_default_instance());
  _FecController_default_instance_.get_mutable()->fec_disabling_threshold_ = const_cast< ::webrtc::audio_network_adaptor::config::FecController_Threshold*>(
      ::webrtc::audio_network_adaptor::config::FecController_Threshold::internal_default_instance());
  _FecControllerRplrBased_default_instance_.get_mutable()->fec_enabling_threshold_ = const_cast< ::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold*>(
      ::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold::internal_default_instance());
  _FecControllerRplrBased_default_instance_.get_mutable()->fec_disabling_threshold_ = const_cast< ::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold*>(
      ::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold::internal_default_instance());
  _Controller_default_instance_.get_mutable()->scoring_point_ = const_cast< ::webrtc::audio_network_adaptor::config::Controller_ScoringPoint*>(
      ::webrtc::audio_network_adaptor::config::Controller_ScoringPoint::internal_default_instance());
}

void InitDefaults() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &TableStruct::InitDefaultsImpl);
}
void AddDescriptorsImpl() {
  InitDefaults();
  ::google::protobuf::internal::OnShutdown(&TableStruct::Shutdown);
}

void AddDescriptors() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);
}

}  // namespace protobuf_config_2eproto


// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int FecController_Threshold::kLowBandwidthBpsFieldNumber;
const int FecController_Threshold::kLowBandwidthPacketLossFieldNumber;
const int FecController_Threshold::kHighBandwidthBpsFieldNumber;
const int FecController_Threshold::kHighBandwidthPacketLossFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

FecController_Threshold::FecController_Threshold()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_config_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.audio_network_adaptor.config.FecController.Threshold)
}
FecController_Threshold::FecController_Threshold(const FecController_Threshold& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&low_bandwidth_bps_, &from.low_bandwidth_bps_,
    static_cast<size_t>(reinterpret_cast<char*>(&high_bandwidth_packet_loss_) -
    reinterpret_cast<char*>(&low_bandwidth_bps_)) + sizeof(high_bandwidth_packet_loss_));
  // @@protoc_insertion_point(copy_constructor:webrtc.audio_network_adaptor.config.FecController.Threshold)
}

void FecController_Threshold::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&low_bandwidth_bps_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&high_bandwidth_packet_loss_) -
      reinterpret_cast<char*>(&low_bandwidth_bps_)) + sizeof(high_bandwidth_packet_loss_));
}

FecController_Threshold::~FecController_Threshold() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.FecController.Threshold)
  SharedDtor();
}

void FecController_Threshold::SharedDtor() {
}

void FecController_Threshold::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const FecController_Threshold& FecController_Threshold::default_instance() {
  protobuf_config_2eproto::InitDefaults();
  return *internal_default_instance();
}

FecController_Threshold* FecController_Threshold::New(::google::protobuf::Arena* arena) const {
  FecController_Threshold* n = new FecController_Threshold;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void FecController_Threshold::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.FecController.Threshold)
  if (_has_bits_[0 / 32] & 15u) {
    ::memset(&low_bandwidth_bps_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&high_bandwidth_packet_loss_) -
        reinterpret_cast<char*>(&low_bandwidth_bps_)) + sizeof(high_bandwidth_packet_loss_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool FecController_Threshold::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:webrtc.audio_network_adaptor.config.FecController.Threshold)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 low_bandwidth_bps = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_low_bandwidth_bps();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &low_bandwidth_bps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float low_bandwidth_packet_loss = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(21u)) {
          set_has_low_bandwidth_packet_loss();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &low_bandwidth_packet_loss_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 high_bandwidth_bps = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_high_bandwidth_bps();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &high_bandwidth_bps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float high_bandwidth_packet_loss = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(37u)) {
          set_has_high_bandwidth_packet_loss();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &high_bandwidth_packet_loss_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.audio_network_adaptor.config.FecController.Threshold)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.audio_network_adaptor.config.FecController.Threshold)
  return false;
#undef DO_
}

void FecController_Threshold::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.audio_network_adaptor.config.FecController.Threshold)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 low_bandwidth_bps = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->low_bandwidth_bps(), output);
  }

  // optional float low_bandwidth_packet_loss = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->low_bandwidth_packet_loss(), output);
  }

  // optional int32 high_bandwidth_bps = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->high_bandwidth_bps(), output);
  }

  // optional float high_bandwidth_packet_loss = 4;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->high_bandwidth_packet_loss(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:webrtc.audio_network_adaptor.config.FecController.Threshold)
}

size_t FecController_Threshold::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.FecController.Threshold)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 15u) {
    // optional int32 low_bandwidth_bps = 1;
    if (has_low_bandwidth_bps()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->low_bandwidth_bps());
    }

    // optional float low_bandwidth_packet_loss = 2;
    if (has_low_bandwidth_packet_loss()) {
      total_size += 1 + 4;
    }

    // optional int32 high_bandwidth_bps = 3;
    if (has_high_bandwidth_bps()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->high_bandwidth_bps());
    }

    // optional float high_bandwidth_packet_loss = 4;
    if (has_high_bandwidth_packet_loss()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void FecController_Threshold::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const FecController_Threshold*>(&from));
}

void FecController_Threshold::MergeFrom(const FecController_Threshold& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.FecController.Threshold)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 15u) {
    if (cached_has_bits & 0x00000001u) {
      low_bandwidth_bps_ = from.low_bandwidth_bps_;
    }
    if (cached_has_bits & 0x00000002u) {
      low_bandwidth_packet_loss_ = from.low_bandwidth_packet_loss_;
    }
    if (cached_has_bits & 0x00000004u) {
      high_bandwidth_bps_ = from.high_bandwidth_bps_;
    }
    if (cached_has_bits & 0x00000008u) {
      high_bandwidth_packet_loss_ = from.high_bandwidth_packet_loss_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void FecController_Threshold::CopyFrom(const FecController_Threshold& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.FecController.Threshold)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool FecController_Threshold::IsInitialized() const {
  return true;
}

void FecController_Threshold::Swap(FecController_Threshold* other) {
  if (other == this) return;
  InternalSwap(other);
}
void FecController_Threshold::InternalSwap(FecController_Threshold* other) {
  std::swap(low_bandwidth_bps_, other->low_bandwidth_bps_);
  std::swap(low_bandwidth_packet_loss_, other->low_bandwidth_packet_loss_);
  std::swap(high_bandwidth_bps_, other->high_bandwidth_bps_);
  std::swap(high_bandwidth_packet_loss_, other->high_bandwidth_packet_loss_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string FecController_Threshold::GetTypeName() const {
  return "webrtc.audio_network_adaptor.config.FecController.Threshold";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// FecController_Threshold

// optional int32 low_bandwidth_bps = 1;
bool FecController_Threshold::has_low_bandwidth_bps() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void FecController_Threshold::set_has_low_bandwidth_bps() {
  _has_bits_[0] |= 0x00000001u;
}
void FecController_Threshold::clear_has_low_bandwidth_bps() {
  _has_bits_[0] &= ~0x00000001u;
}
void FecController_Threshold::clear_low_bandwidth_bps() {
  low_bandwidth_bps_ = 0;
  clear_has_low_bandwidth_bps();
}
::google::protobuf::int32 FecController_Threshold::low_bandwidth_bps() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.FecController.Threshold.low_bandwidth_bps)
  return low_bandwidth_bps_;
}
void FecController_Threshold::set_low_bandwidth_bps(::google::protobuf::int32 value) {
  set_has_low_bandwidth_bps();
  low_bandwidth_bps_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.FecController.Threshold.low_bandwidth_bps)
}

// optional float low_bandwidth_packet_loss = 2;
bool FecController_Threshold::has_low_bandwidth_packet_loss() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void FecController_Threshold::set_has_low_bandwidth_packet_loss() {
  _has_bits_[0] |= 0x00000002u;
}
void FecController_Threshold::clear_has_low_bandwidth_packet_loss() {
  _has_bits_[0] &= ~0x00000002u;
}
void FecController_Threshold::clear_low_bandwidth_packet_loss() {
  low_bandwidth_packet_loss_ = 0;
  clear_has_low_bandwidth_packet_loss();
}
float FecController_Threshold::low_bandwidth_packet_loss() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.FecController.Threshold.low_bandwidth_packet_loss)
  return low_bandwidth_packet_loss_;
}
void FecController_Threshold::set_low_bandwidth_packet_loss(float value) {
  set_has_low_bandwidth_packet_loss();
  low_bandwidth_packet_loss_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.FecController.Threshold.low_bandwidth_packet_loss)
}

// optional int32 high_bandwidth_bps = 3;
bool FecController_Threshold::has_high_bandwidth_bps() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void FecController_Threshold::set_has_high_bandwidth_bps() {
  _has_bits_[0] |= 0x00000004u;
}
void FecController_Threshold::clear_has_high_bandwidth_bps() {
  _has_bits_[0] &= ~0x00000004u;
}
void FecController_Threshold::clear_high_bandwidth_bps() {
  high_bandwidth_bps_ = 0;
  clear_has_high_bandwidth_bps();
}
::google::protobuf::int32 FecController_Threshold::high_bandwidth_bps() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.FecController.Threshold.high_bandwidth_bps)
  return high_bandwidth_bps_;
}
void FecController_Threshold::set_high_bandwidth_bps(::google::protobuf::int32 value) {
  set_has_high_bandwidth_bps();
  high_bandwidth_bps_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.FecController.Threshold.high_bandwidth_bps)
}

// optional float high_bandwidth_packet_loss = 4;
bool FecController_Threshold::has_high_bandwidth_packet_loss() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void FecController_Threshold::set_has_high_bandwidth_packet_loss() {
  _has_bits_[0] |= 0x00000008u;
}
void FecController_Threshold::clear_has_high_bandwidth_packet_loss() {
  _has_bits_[0] &= ~0x00000008u;
}
void FecController_Threshold::clear_high_bandwidth_packet_loss() {
  high_bandwidth_packet_loss_ = 0;
  clear_has_high_bandwidth_packet_loss();
}
float FecController_Threshold::high_bandwidth_packet_loss() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.FecController.Threshold.high_bandwidth_packet_loss)
  return high_bandwidth_packet_loss_;
}
void FecController_Threshold::set_high_bandwidth_packet_loss(float value) {
  set_has_high_bandwidth_packet_loss();
  high_bandwidth_packet_loss_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.FecController.Threshold.high_bandwidth_packet_loss)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int FecController::kFecEnablingThresholdFieldNumber;
const int FecController::kFecDisablingThresholdFieldNumber;
const int FecController::kTimeConstantMsFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

FecController::FecController()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_config_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.audio_network_adaptor.config.FecController)
}
FecController::FecController(const FecController& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_fec_enabling_threshold()) {
    fec_enabling_threshold_ = new ::webrtc::audio_network_adaptor::config::FecController_Threshold(*from.fec_enabling_threshold_);
  } else {
    fec_enabling_threshold_ = NULL;
  }
  if (from.has_fec_disabling_threshold()) {
    fec_disabling_threshold_ = new ::webrtc::audio_network_adaptor::config::FecController_Threshold(*from.fec_disabling_threshold_);
  } else {
    fec_disabling_threshold_ = NULL;
  }
  time_constant_ms_ = from.time_constant_ms_;
  // @@protoc_insertion_point(copy_constructor:webrtc.audio_network_adaptor.config.FecController)
}

void FecController::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&fec_enabling_threshold_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&time_constant_ms_) -
      reinterpret_cast<char*>(&fec_enabling_threshold_)) + sizeof(time_constant_ms_));
}

FecController::~FecController() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.FecController)
  SharedDtor();
}

void FecController::SharedDtor() {
  if (this != internal_default_instance()) {
    delete fec_enabling_threshold_;
  }
  if (this != internal_default_instance()) {
    delete fec_disabling_threshold_;
  }
}

void FecController::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const FecController& FecController::default_instance() {
  protobuf_config_2eproto::InitDefaults();
  return *internal_default_instance();
}

FecController* FecController::New(::google::protobuf::Arena* arena) const {
  FecController* n = new FecController;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void FecController::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.FecController)
  if (_has_bits_[0 / 32] & 3u) {
    if (has_fec_enabling_threshold()) {
      GOOGLE_DCHECK(fec_enabling_threshold_ != NULL);
      fec_enabling_threshold_->::webrtc::audio_network_adaptor::config::FecController_Threshold::Clear();
    }
    if (has_fec_disabling_threshold()) {
      GOOGLE_DCHECK(fec_disabling_threshold_ != NULL);
      fec_disabling_threshold_->::webrtc::audio_network_adaptor::config::FecController_Threshold::Clear();
    }
  }
  time_constant_ms_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool FecController::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:webrtc.audio_network_adaptor.config.FecController)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .webrtc.audio_network_adaptor.config.FecController.Threshold fec_enabling_threshold = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_fec_enabling_threshold()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.audio_network_adaptor.config.FecController.Threshold fec_disabling_threshold = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_fec_disabling_threshold()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 time_constant_ms = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_time_constant_ms();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &time_constant_ms_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.audio_network_adaptor.config.FecController)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.audio_network_adaptor.config.FecController)
  return false;
#undef DO_
}

void FecController::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.audio_network_adaptor.config.FecController)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .webrtc.audio_network_adaptor.config.FecController.Threshold fec_enabling_threshold = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, *this->fec_enabling_threshold_, output);
  }

  // optional .webrtc.audio_network_adaptor.config.FecController.Threshold fec_disabling_threshold = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, *this->fec_disabling_threshold_, output);
  }

  // optional int32 time_constant_ms = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->time_constant_ms(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:webrtc.audio_network_adaptor.config.FecController)
}

size_t FecController::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.FecController)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 7u) {
    // optional .webrtc.audio_network_adaptor.config.FecController.Threshold fec_enabling_threshold = 1;
    if (has_fec_enabling_threshold()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->fec_enabling_threshold_);
    }

    // optional .webrtc.audio_network_adaptor.config.FecController.Threshold fec_disabling_threshold = 2;
    if (has_fec_disabling_threshold()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->fec_disabling_threshold_);
    }

    // optional int32 time_constant_ms = 3;
    if (has_time_constant_ms()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->time_constant_ms());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void FecController::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const FecController*>(&from));
}

void FecController::MergeFrom(const FecController& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.FecController)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_fec_enabling_threshold()->::webrtc::audio_network_adaptor::config::FecController_Threshold::MergeFrom(from.fec_enabling_threshold());
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_fec_disabling_threshold()->::webrtc::audio_network_adaptor::config::FecController_Threshold::MergeFrom(from.fec_disabling_threshold());
    }
    if (cached_has_bits & 0x00000004u) {
      time_constant_ms_ = from.time_constant_ms_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void FecController::CopyFrom(const FecController& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.FecController)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool FecController::IsInitialized() const {
  return true;
}

void FecController::Swap(FecController* other) {
  if (other == this) return;
  InternalSwap(other);
}
void FecController::InternalSwap(FecController* other) {
  std::swap(fec_enabling_threshold_, other->fec_enabling_threshold_);
  std::swap(fec_disabling_threshold_, other->fec_disabling_threshold_);
  std::swap(time_constant_ms_, other->time_constant_ms_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string FecController::GetTypeName() const {
  return "webrtc.audio_network_adaptor.config.FecController";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// FecController

// optional .webrtc.audio_network_adaptor.config.FecController.Threshold fec_enabling_threshold = 1;
bool FecController::has_fec_enabling_threshold() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void FecController::set_has_fec_enabling_threshold() {
  _has_bits_[0] |= 0x00000001u;
}
void FecController::clear_has_fec_enabling_threshold() {
  _has_bits_[0] &= ~0x00000001u;
}
void FecController::clear_fec_enabling_threshold() {
  if (fec_enabling_threshold_ != NULL) fec_enabling_threshold_->::webrtc::audio_network_adaptor::config::FecController_Threshold::Clear();
  clear_has_fec_enabling_threshold();
}
const ::webrtc::audio_network_adaptor::config::FecController_Threshold& FecController::fec_enabling_threshold() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.FecController.fec_enabling_threshold)
  return fec_enabling_threshold_ != NULL ? *fec_enabling_threshold_
                         : *::webrtc::audio_network_adaptor::config::FecController_Threshold::internal_default_instance();
}
::webrtc::audio_network_adaptor::config::FecController_Threshold* FecController::mutable_fec_enabling_threshold() {
  set_has_fec_enabling_threshold();
  if (fec_enabling_threshold_ == NULL) {
    fec_enabling_threshold_ = new ::webrtc::audio_network_adaptor::config::FecController_Threshold;
  }
  // @@protoc_insertion_point(field_mutable:webrtc.audio_network_adaptor.config.FecController.fec_enabling_threshold)
  return fec_enabling_threshold_;
}
::webrtc::audio_network_adaptor::config::FecController_Threshold* FecController::release_fec_enabling_threshold() {
  // @@protoc_insertion_point(field_release:webrtc.audio_network_adaptor.config.FecController.fec_enabling_threshold)
  clear_has_fec_enabling_threshold();
  ::webrtc::audio_network_adaptor::config::FecController_Threshold* temp = fec_enabling_threshold_;
  fec_enabling_threshold_ = NULL;
  return temp;
}
void FecController::set_allocated_fec_enabling_threshold(::webrtc::audio_network_adaptor::config::FecController_Threshold* fec_enabling_threshold) {
  delete fec_enabling_threshold_;
  fec_enabling_threshold_ = fec_enabling_threshold;
  if (fec_enabling_threshold) {
    set_has_fec_enabling_threshold();
  } else {
    clear_has_fec_enabling_threshold();
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audio_network_adaptor.config.FecController.fec_enabling_threshold)
}

// optional .webrtc.audio_network_adaptor.config.FecController.Threshold fec_disabling_threshold = 2;
bool FecController::has_fec_disabling_threshold() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void FecController::set_has_fec_disabling_threshold() {
  _has_bits_[0] |= 0x00000002u;
}
void FecController::clear_has_fec_disabling_threshold() {
  _has_bits_[0] &= ~0x00000002u;
}
void FecController::clear_fec_disabling_threshold() {
  if (fec_disabling_threshold_ != NULL) fec_disabling_threshold_->::webrtc::audio_network_adaptor::config::FecController_Threshold::Clear();
  clear_has_fec_disabling_threshold();
}
const ::webrtc::audio_network_adaptor::config::FecController_Threshold& FecController::fec_disabling_threshold() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.FecController.fec_disabling_threshold)
  return fec_disabling_threshold_ != NULL ? *fec_disabling_threshold_
                         : *::webrtc::audio_network_adaptor::config::FecController_Threshold::internal_default_instance();
}
::webrtc::audio_network_adaptor::config::FecController_Threshold* FecController::mutable_fec_disabling_threshold() {
  set_has_fec_disabling_threshold();
  if (fec_disabling_threshold_ == NULL) {
    fec_disabling_threshold_ = new ::webrtc::audio_network_adaptor::config::FecController_Threshold;
  }
  // @@protoc_insertion_point(field_mutable:webrtc.audio_network_adaptor.config.FecController.fec_disabling_threshold)
  return fec_disabling_threshold_;
}
::webrtc::audio_network_adaptor::config::FecController_Threshold* FecController::release_fec_disabling_threshold() {
  // @@protoc_insertion_point(field_release:webrtc.audio_network_adaptor.config.FecController.fec_disabling_threshold)
  clear_has_fec_disabling_threshold();
  ::webrtc::audio_network_adaptor::config::FecController_Threshold* temp = fec_disabling_threshold_;
  fec_disabling_threshold_ = NULL;
  return temp;
}
void FecController::set_allocated_fec_disabling_threshold(::webrtc::audio_network_adaptor::config::FecController_Threshold* fec_disabling_threshold) {
  delete fec_disabling_threshold_;
  fec_disabling_threshold_ = fec_disabling_threshold;
  if (fec_disabling_threshold) {
    set_has_fec_disabling_threshold();
  } else {
    clear_has_fec_disabling_threshold();
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audio_network_adaptor.config.FecController.fec_disabling_threshold)
}

// optional int32 time_constant_ms = 3;
bool FecController::has_time_constant_ms() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void FecController::set_has_time_constant_ms() {
  _has_bits_[0] |= 0x00000004u;
}
void FecController::clear_has_time_constant_ms() {
  _has_bits_[0] &= ~0x00000004u;
}
void FecController::clear_time_constant_ms() {
  time_constant_ms_ = 0;
  clear_has_time_constant_ms();
}
::google::protobuf::int32 FecController::time_constant_ms() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.FecController.time_constant_ms)
  return time_constant_ms_;
}
void FecController::set_time_constant_ms(::google::protobuf::int32 value) {
  set_has_time_constant_ms();
  time_constant_ms_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.FecController.time_constant_ms)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int FecControllerRplrBased_Threshold::kLowBandwidthBpsFieldNumber;
const int FecControllerRplrBased_Threshold::kLowBandwidthRecoverablePacketLossFieldNumber;
const int FecControllerRplrBased_Threshold::kHighBandwidthBpsFieldNumber;
const int FecControllerRplrBased_Threshold::kHighBandwidthRecoverablePacketLossFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

FecControllerRplrBased_Threshold::FecControllerRplrBased_Threshold()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_config_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold)
}
FecControllerRplrBased_Threshold::FecControllerRplrBased_Threshold(const FecControllerRplrBased_Threshold& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&low_bandwidth_bps_, &from.low_bandwidth_bps_,
    static_cast<size_t>(reinterpret_cast<char*>(&high_bandwidth_recoverable_packet_loss_) -
    reinterpret_cast<char*>(&low_bandwidth_bps_)) + sizeof(high_bandwidth_recoverable_packet_loss_));
  // @@protoc_insertion_point(copy_constructor:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold)
}

void FecControllerRplrBased_Threshold::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&low_bandwidth_bps_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&high_bandwidth_recoverable_packet_loss_) -
      reinterpret_cast<char*>(&low_bandwidth_bps_)) + sizeof(high_bandwidth_recoverable_packet_loss_));
}

FecControllerRplrBased_Threshold::~FecControllerRplrBased_Threshold() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold)
  SharedDtor();
}

void FecControllerRplrBased_Threshold::SharedDtor() {
}

void FecControllerRplrBased_Threshold::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const FecControllerRplrBased_Threshold& FecControllerRplrBased_Threshold::default_instance() {
  protobuf_config_2eproto::InitDefaults();
  return *internal_default_instance();
}

FecControllerRplrBased_Threshold* FecControllerRplrBased_Threshold::New(::google::protobuf::Arena* arena) const {
  FecControllerRplrBased_Threshold* n = new FecControllerRplrBased_Threshold;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void FecControllerRplrBased_Threshold::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold)
  if (_has_bits_[0 / 32] & 15u) {
    ::memset(&low_bandwidth_bps_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&high_bandwidth_recoverable_packet_loss_) -
        reinterpret_cast<char*>(&low_bandwidth_bps_)) + sizeof(high_bandwidth_recoverable_packet_loss_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool FecControllerRplrBased_Threshold::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 low_bandwidth_bps = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_low_bandwidth_bps();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &low_bandwidth_bps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float low_bandwidth_recoverable_packet_loss = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(21u)) {
          set_has_low_bandwidth_recoverable_packet_loss();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &low_bandwidth_recoverable_packet_loss_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 high_bandwidth_bps = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_high_bandwidth_bps();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &high_bandwidth_bps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float high_bandwidth_recoverable_packet_loss = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(37u)) {
          set_has_high_bandwidth_recoverable_packet_loss();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &high_bandwidth_recoverable_packet_loss_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold)
  return false;
#undef DO_
}

void FecControllerRplrBased_Threshold::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 low_bandwidth_bps = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->low_bandwidth_bps(), output);
  }

  // optional float low_bandwidth_recoverable_packet_loss = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->low_bandwidth_recoverable_packet_loss(), output);
  }

  // optional int32 high_bandwidth_bps = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->high_bandwidth_bps(), output);
  }

  // optional float high_bandwidth_recoverable_packet_loss = 4;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->high_bandwidth_recoverable_packet_loss(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold)
}

size_t FecControllerRplrBased_Threshold::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 15u) {
    // optional int32 low_bandwidth_bps = 1;
    if (has_low_bandwidth_bps()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->low_bandwidth_bps());
    }

    // optional float low_bandwidth_recoverable_packet_loss = 2;
    if (has_low_bandwidth_recoverable_packet_loss()) {
      total_size += 1 + 4;
    }

    // optional int32 high_bandwidth_bps = 3;
    if (has_high_bandwidth_bps()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->high_bandwidth_bps());
    }

    // optional float high_bandwidth_recoverable_packet_loss = 4;
    if (has_high_bandwidth_recoverable_packet_loss()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void FecControllerRplrBased_Threshold::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const FecControllerRplrBased_Threshold*>(&from));
}

void FecControllerRplrBased_Threshold::MergeFrom(const FecControllerRplrBased_Threshold& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 15u) {
    if (cached_has_bits & 0x00000001u) {
      low_bandwidth_bps_ = from.low_bandwidth_bps_;
    }
    if (cached_has_bits & 0x00000002u) {
      low_bandwidth_recoverable_packet_loss_ = from.low_bandwidth_recoverable_packet_loss_;
    }
    if (cached_has_bits & 0x00000004u) {
      high_bandwidth_bps_ = from.high_bandwidth_bps_;
    }
    if (cached_has_bits & 0x00000008u) {
      high_bandwidth_recoverable_packet_loss_ = from.high_bandwidth_recoverable_packet_loss_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void FecControllerRplrBased_Threshold::CopyFrom(const FecControllerRplrBased_Threshold& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool FecControllerRplrBased_Threshold::IsInitialized() const {
  return true;
}

void FecControllerRplrBased_Threshold::Swap(FecControllerRplrBased_Threshold* other) {
  if (other == this) return;
  InternalSwap(other);
}
void FecControllerRplrBased_Threshold::InternalSwap(FecControllerRplrBased_Threshold* other) {
  std::swap(low_bandwidth_bps_, other->low_bandwidth_bps_);
  std::swap(low_bandwidth_recoverable_packet_loss_, other->low_bandwidth_recoverable_packet_loss_);
  std::swap(high_bandwidth_bps_, other->high_bandwidth_bps_);
  std::swap(high_bandwidth_recoverable_packet_loss_, other->high_bandwidth_recoverable_packet_loss_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string FecControllerRplrBased_Threshold::GetTypeName() const {
  return "webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// FecControllerRplrBased_Threshold

// optional int32 low_bandwidth_bps = 1;
bool FecControllerRplrBased_Threshold::has_low_bandwidth_bps() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void FecControllerRplrBased_Threshold::set_has_low_bandwidth_bps() {
  _has_bits_[0] |= 0x00000001u;
}
void FecControllerRplrBased_Threshold::clear_has_low_bandwidth_bps() {
  _has_bits_[0] &= ~0x00000001u;
}
void FecControllerRplrBased_Threshold::clear_low_bandwidth_bps() {
  low_bandwidth_bps_ = 0;
  clear_has_low_bandwidth_bps();
}
::google::protobuf::int32 FecControllerRplrBased_Threshold::low_bandwidth_bps() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold.low_bandwidth_bps)
  return low_bandwidth_bps_;
}
void FecControllerRplrBased_Threshold::set_low_bandwidth_bps(::google::protobuf::int32 value) {
  set_has_low_bandwidth_bps();
  low_bandwidth_bps_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold.low_bandwidth_bps)
}

// optional float low_bandwidth_recoverable_packet_loss = 2;
bool FecControllerRplrBased_Threshold::has_low_bandwidth_recoverable_packet_loss() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void FecControllerRplrBased_Threshold::set_has_low_bandwidth_recoverable_packet_loss() {
  _has_bits_[0] |= 0x00000002u;
}
void FecControllerRplrBased_Threshold::clear_has_low_bandwidth_recoverable_packet_loss() {
  _has_bits_[0] &= ~0x00000002u;
}
void FecControllerRplrBased_Threshold::clear_low_bandwidth_recoverable_packet_loss() {
  low_bandwidth_recoverable_packet_loss_ = 0;
  clear_has_low_bandwidth_recoverable_packet_loss();
}
float FecControllerRplrBased_Threshold::low_bandwidth_recoverable_packet_loss() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold.low_bandwidth_recoverable_packet_loss)
  return low_bandwidth_recoverable_packet_loss_;
}
void FecControllerRplrBased_Threshold::set_low_bandwidth_recoverable_packet_loss(float value) {
  set_has_low_bandwidth_recoverable_packet_loss();
  low_bandwidth_recoverable_packet_loss_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold.low_bandwidth_recoverable_packet_loss)
}

// optional int32 high_bandwidth_bps = 3;
bool FecControllerRplrBased_Threshold::has_high_bandwidth_bps() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void FecControllerRplrBased_Threshold::set_has_high_bandwidth_bps() {
  _has_bits_[0] |= 0x00000004u;
}
void FecControllerRplrBased_Threshold::clear_has_high_bandwidth_bps() {
  _has_bits_[0] &= ~0x00000004u;
}
void FecControllerRplrBased_Threshold::clear_high_bandwidth_bps() {
  high_bandwidth_bps_ = 0;
  clear_has_high_bandwidth_bps();
}
::google::protobuf::int32 FecControllerRplrBased_Threshold::high_bandwidth_bps() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold.high_bandwidth_bps)
  return high_bandwidth_bps_;
}
void FecControllerRplrBased_Threshold::set_high_bandwidth_bps(::google::protobuf::int32 value) {
  set_has_high_bandwidth_bps();
  high_bandwidth_bps_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold.high_bandwidth_bps)
}

// optional float high_bandwidth_recoverable_packet_loss = 4;
bool FecControllerRplrBased_Threshold::has_high_bandwidth_recoverable_packet_loss() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void FecControllerRplrBased_Threshold::set_has_high_bandwidth_recoverable_packet_loss() {
  _has_bits_[0] |= 0x00000008u;
}
void FecControllerRplrBased_Threshold::clear_has_high_bandwidth_recoverable_packet_loss() {
  _has_bits_[0] &= ~0x00000008u;
}
void FecControllerRplrBased_Threshold::clear_high_bandwidth_recoverable_packet_loss() {
  high_bandwidth_recoverable_packet_loss_ = 0;
  clear_has_high_bandwidth_recoverable_packet_loss();
}
float FecControllerRplrBased_Threshold::high_bandwidth_recoverable_packet_loss() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold.high_bandwidth_recoverable_packet_loss)
  return high_bandwidth_recoverable_packet_loss_;
}
void FecControllerRplrBased_Threshold::set_high_bandwidth_recoverable_packet_loss(float value) {
  set_has_high_bandwidth_recoverable_packet_loss();
  high_bandwidth_recoverable_packet_loss_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold.high_bandwidth_recoverable_packet_loss)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int FecControllerRplrBased::kFecEnablingThresholdFieldNumber;
const int FecControllerRplrBased::kFecDisablingThresholdFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

FecControllerRplrBased::FecControllerRplrBased()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_config_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.audio_network_adaptor.config.FecControllerRplrBased)
}
FecControllerRplrBased::FecControllerRplrBased(const FecControllerRplrBased& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_fec_enabling_threshold()) {
    fec_enabling_threshold_ = new ::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold(*from.fec_enabling_threshold_);
  } else {
    fec_enabling_threshold_ = NULL;
  }
  if (from.has_fec_disabling_threshold()) {
    fec_disabling_threshold_ = new ::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold(*from.fec_disabling_threshold_);
  } else {
    fec_disabling_threshold_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:webrtc.audio_network_adaptor.config.FecControllerRplrBased)
}

void FecControllerRplrBased::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&fec_enabling_threshold_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&fec_disabling_threshold_) -
      reinterpret_cast<char*>(&fec_enabling_threshold_)) + sizeof(fec_disabling_threshold_));
}

FecControllerRplrBased::~FecControllerRplrBased() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.FecControllerRplrBased)
  SharedDtor();
}

void FecControllerRplrBased::SharedDtor() {
  if (this != internal_default_instance()) {
    delete fec_enabling_threshold_;
  }
  if (this != internal_default_instance()) {
    delete fec_disabling_threshold_;
  }
}

void FecControllerRplrBased::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const FecControllerRplrBased& FecControllerRplrBased::default_instance() {
  protobuf_config_2eproto::InitDefaults();
  return *internal_default_instance();
}

FecControllerRplrBased* FecControllerRplrBased::New(::google::protobuf::Arena* arena) const {
  FecControllerRplrBased* n = new FecControllerRplrBased;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void FecControllerRplrBased::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased)
  if (_has_bits_[0 / 32] & 3u) {
    if (has_fec_enabling_threshold()) {
      GOOGLE_DCHECK(fec_enabling_threshold_ != NULL);
      fec_enabling_threshold_->::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold::Clear();
    }
    if (has_fec_disabling_threshold()) {
      GOOGLE_DCHECK(fec_disabling_threshold_ != NULL);
      fec_disabling_threshold_->::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold::Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool FecControllerRplrBased::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold fec_enabling_threshold = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_fec_enabling_threshold()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold fec_disabling_threshold = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_fec_disabling_threshold()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.audio_network_adaptor.config.FecControllerRplrBased)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.audio_network_adaptor.config.FecControllerRplrBased)
  return false;
#undef DO_
}

void FecControllerRplrBased::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold fec_enabling_threshold = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, *this->fec_enabling_threshold_, output);
  }

  // optional .webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold fec_disabling_threshold = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, *this->fec_disabling_threshold_, output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:webrtc.audio_network_adaptor.config.FecControllerRplrBased)
}

size_t FecControllerRplrBased::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 3u) {
    // optional .webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold fec_enabling_threshold = 1;
    if (has_fec_enabling_threshold()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->fec_enabling_threshold_);
    }

    // optional .webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold fec_disabling_threshold = 2;
    if (has_fec_disabling_threshold()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->fec_disabling_threshold_);
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void FecControllerRplrBased::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const FecControllerRplrBased*>(&from));
}

void FecControllerRplrBased::MergeFrom(const FecControllerRplrBased& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_fec_enabling_threshold()->::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold::MergeFrom(from.fec_enabling_threshold());
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_fec_disabling_threshold()->::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold::MergeFrom(from.fec_disabling_threshold());
    }
  }
}

void FecControllerRplrBased::CopyFrom(const FecControllerRplrBased& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.FecControllerRplrBased)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool FecControllerRplrBased::IsInitialized() const {
  return true;
}

void FecControllerRplrBased::Swap(FecControllerRplrBased* other) {
  if (other == this) return;
  InternalSwap(other);
}
void FecControllerRplrBased::InternalSwap(FecControllerRplrBased* other) {
  std::swap(fec_enabling_threshold_, other->fec_enabling_threshold_);
  std::swap(fec_disabling_threshold_, other->fec_disabling_threshold_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string FecControllerRplrBased::GetTypeName() const {
  return "webrtc.audio_network_adaptor.config.FecControllerRplrBased";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// FecControllerRplrBased

// optional .webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold fec_enabling_threshold = 1;
bool FecControllerRplrBased::has_fec_enabling_threshold() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void FecControllerRplrBased::set_has_fec_enabling_threshold() {
  _has_bits_[0] |= 0x00000001u;
}
void FecControllerRplrBased::clear_has_fec_enabling_threshold() {
  _has_bits_[0] &= ~0x00000001u;
}
void FecControllerRplrBased::clear_fec_enabling_threshold() {
  if (fec_enabling_threshold_ != NULL) fec_enabling_threshold_->::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold::Clear();
  clear_has_fec_enabling_threshold();
}
const ::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold& FecControllerRplrBased::fec_enabling_threshold() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.FecControllerRplrBased.fec_enabling_threshold)
  return fec_enabling_threshold_ != NULL ? *fec_enabling_threshold_
                         : *::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold::internal_default_instance();
}
::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold* FecControllerRplrBased::mutable_fec_enabling_threshold() {
  set_has_fec_enabling_threshold();
  if (fec_enabling_threshold_ == NULL) {
    fec_enabling_threshold_ = new ::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold;
  }
  // @@protoc_insertion_point(field_mutable:webrtc.audio_network_adaptor.config.FecControllerRplrBased.fec_enabling_threshold)
  return fec_enabling_threshold_;
}
::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold* FecControllerRplrBased::release_fec_enabling_threshold() {
  // @@protoc_insertion_point(field_release:webrtc.audio_network_adaptor.config.FecControllerRplrBased.fec_enabling_threshold)
  clear_has_fec_enabling_threshold();
  ::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold* temp = fec_enabling_threshold_;
  fec_enabling_threshold_ = NULL;
  return temp;
}
void FecControllerRplrBased::set_allocated_fec_enabling_threshold(::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold* fec_enabling_threshold) {
  delete fec_enabling_threshold_;
  fec_enabling_threshold_ = fec_enabling_threshold;
  if (fec_enabling_threshold) {
    set_has_fec_enabling_threshold();
  } else {
    clear_has_fec_enabling_threshold();
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audio_network_adaptor.config.FecControllerRplrBased.fec_enabling_threshold)
}

// optional .webrtc.audio_network_adaptor.config.FecControllerRplrBased.Threshold fec_disabling_threshold = 2;
bool FecControllerRplrBased::has_fec_disabling_threshold() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void FecControllerRplrBased::set_has_fec_disabling_threshold() {
  _has_bits_[0] |= 0x00000002u;
}
void FecControllerRplrBased::clear_has_fec_disabling_threshold() {
  _has_bits_[0] &= ~0x00000002u;
}
void FecControllerRplrBased::clear_fec_disabling_threshold() {
  if (fec_disabling_threshold_ != NULL) fec_disabling_threshold_->::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold::Clear();
  clear_has_fec_disabling_threshold();
}
const ::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold& FecControllerRplrBased::fec_disabling_threshold() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.FecControllerRplrBased.fec_disabling_threshold)
  return fec_disabling_threshold_ != NULL ? *fec_disabling_threshold_
                         : *::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold::internal_default_instance();
}
::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold* FecControllerRplrBased::mutable_fec_disabling_threshold() {
  set_has_fec_disabling_threshold();
  if (fec_disabling_threshold_ == NULL) {
    fec_disabling_threshold_ = new ::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold;
  }
  // @@protoc_insertion_point(field_mutable:webrtc.audio_network_adaptor.config.FecControllerRplrBased.fec_disabling_threshold)
  return fec_disabling_threshold_;
}
::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold* FecControllerRplrBased::release_fec_disabling_threshold() {
  // @@protoc_insertion_point(field_release:webrtc.audio_network_adaptor.config.FecControllerRplrBased.fec_disabling_threshold)
  clear_has_fec_disabling_threshold();
  ::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold* temp = fec_disabling_threshold_;
  fec_disabling_threshold_ = NULL;
  return temp;
}
void FecControllerRplrBased::set_allocated_fec_disabling_threshold(::webrtc::audio_network_adaptor::config::FecControllerRplrBased_Threshold* fec_disabling_threshold) {
  delete fec_disabling_threshold_;
  fec_disabling_threshold_ = fec_disabling_threshold;
  if (fec_disabling_threshold) {
    set_has_fec_disabling_threshold();
  } else {
    clear_has_fec_disabling_threshold();
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audio_network_adaptor.config.FecControllerRplrBased.fec_disabling_threshold)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int FrameLengthController::kFlIncreasingPacketLossFractionFieldNumber;
const int FrameLengthController::kFlDecreasingPacketLossFractionFieldNumber;
const int FrameLengthController::kFl20MsTo60MsBandwidthBpsFieldNumber;
const int FrameLengthController::kFl60MsTo20MsBandwidthBpsFieldNumber;
const int FrameLengthController::kFl60MsTo120MsBandwidthBpsFieldNumber;
const int FrameLengthController::kFl120MsTo60MsBandwidthBpsFieldNumber;
const int FrameLengthController::kFlIncreaseOverheadOffsetFieldNumber;
const int FrameLengthController::kFlDecreaseOverheadOffsetFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

FrameLengthController::FrameLengthController()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_config_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.audio_network_adaptor.config.FrameLengthController)
}
FrameLengthController::FrameLengthController(const FrameLengthController& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&fl_increasing_packet_loss_fraction_, &from.fl_increasing_packet_loss_fraction_,
    static_cast<size_t>(reinterpret_cast<char*>(&fl_decrease_overhead_offset_) -
    reinterpret_cast<char*>(&fl_increasing_packet_loss_fraction_)) + sizeof(fl_decrease_overhead_offset_));
  // @@protoc_insertion_point(copy_constructor:webrtc.audio_network_adaptor.config.FrameLengthController)
}

void FrameLengthController::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&fl_increasing_packet_loss_fraction_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&fl_decrease_overhead_offset_) -
      reinterpret_cast<char*>(&fl_increasing_packet_loss_fraction_)) + sizeof(fl_decrease_overhead_offset_));
}

FrameLengthController::~FrameLengthController() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.FrameLengthController)
  SharedDtor();
}

void FrameLengthController::SharedDtor() {
}

void FrameLengthController::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const FrameLengthController& FrameLengthController::default_instance() {
  protobuf_config_2eproto::InitDefaults();
  return *internal_default_instance();
}

FrameLengthController* FrameLengthController::New(::google::protobuf::Arena* arena) const {
  FrameLengthController* n = new FrameLengthController;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void FrameLengthController::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.FrameLengthController)
  if (_has_bits_[0 / 32] & 255u) {
    ::memset(&fl_increasing_packet_loss_fraction_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&fl_decrease_overhead_offset_) -
        reinterpret_cast<char*>(&fl_increasing_packet_loss_fraction_)) + sizeof(fl_decrease_overhead_offset_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool FrameLengthController::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:webrtc.audio_network_adaptor.config.FrameLengthController)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional float fl_increasing_packet_loss_fraction = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(13u)) {
          set_has_fl_increasing_packet_loss_fraction();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &fl_increasing_packet_loss_fraction_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float fl_decreasing_packet_loss_fraction = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(21u)) {
          set_has_fl_decreasing_packet_loss_fraction();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &fl_decreasing_packet_loss_fraction_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 fl_20ms_to_60ms_bandwidth_bps = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_fl_20ms_to_60ms_bandwidth_bps();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &fl_20ms_to_60ms_bandwidth_bps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 fl_60ms_to_20ms_bandwidth_bps = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u)) {
          set_has_fl_60ms_to_20ms_bandwidth_bps();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &fl_60ms_to_20ms_bandwidth_bps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 fl_60ms_to_120ms_bandwidth_bps = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u)) {
          set_has_fl_60ms_to_120ms_bandwidth_bps();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &fl_60ms_to_120ms_bandwidth_bps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 fl_120ms_to_60ms_bandwidth_bps = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u)) {
          set_has_fl_120ms_to_60ms_bandwidth_bps();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &fl_120ms_to_60ms_bandwidth_bps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 fl_increase_overhead_offset = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(56u)) {
          set_has_fl_increase_overhead_offset();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &fl_increase_overhead_offset_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 fl_decrease_overhead_offset = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(64u)) {
          set_has_fl_decrease_overhead_offset();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &fl_decrease_overhead_offset_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.audio_network_adaptor.config.FrameLengthController)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.audio_network_adaptor.config.FrameLengthController)
  return false;
#undef DO_
}

void FrameLengthController::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.audio_network_adaptor.config.FrameLengthController)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional float fl_increasing_packet_loss_fraction = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->fl_increasing_packet_loss_fraction(), output);
  }

  // optional float fl_decreasing_packet_loss_fraction = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->fl_decreasing_packet_loss_fraction(), output);
  }

  // optional int32 fl_20ms_to_60ms_bandwidth_bps = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->fl_20ms_to_60ms_bandwidth_bps(), output);
  }

  // optional int32 fl_60ms_to_20ms_bandwidth_bps = 4;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->fl_60ms_to_20ms_bandwidth_bps(), output);
  }

  // optional int32 fl_60ms_to_120ms_bandwidth_bps = 5;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->fl_60ms_to_120ms_bandwidth_bps(), output);
  }

  // optional int32 fl_120ms_to_60ms_bandwidth_bps = 6;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->fl_120ms_to_60ms_bandwidth_bps(), output);
  }

  // optional int32 fl_increase_overhead_offset = 7;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->fl_increase_overhead_offset(), output);
  }

  // optional int32 fl_decrease_overhead_offset = 8;
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(8, this->fl_decrease_overhead_offset(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:webrtc.audio_network_adaptor.config.FrameLengthController)
}

size_t FrameLengthController::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.FrameLengthController)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 255u) {
    // optional float fl_increasing_packet_loss_fraction = 1;
    if (has_fl_increasing_packet_loss_fraction()) {
      total_size += 1 + 4;
    }

    // optional float fl_decreasing_packet_loss_fraction = 2;
    if (has_fl_decreasing_packet_loss_fraction()) {
      total_size += 1 + 4;
    }

    // optional int32 fl_20ms_to_60ms_bandwidth_bps = 3;
    if (has_fl_20ms_to_60ms_bandwidth_bps()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->fl_20ms_to_60ms_bandwidth_bps());
    }

    // optional int32 fl_60ms_to_20ms_bandwidth_bps = 4;
    if (has_fl_60ms_to_20ms_bandwidth_bps()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->fl_60ms_to_20ms_bandwidth_bps());
    }

    // optional int32 fl_60ms_to_120ms_bandwidth_bps = 5;
    if (has_fl_60ms_to_120ms_bandwidth_bps()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->fl_60ms_to_120ms_bandwidth_bps());
    }

    // optional int32 fl_120ms_to_60ms_bandwidth_bps = 6;
    if (has_fl_120ms_to_60ms_bandwidth_bps()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->fl_120ms_to_60ms_bandwidth_bps());
    }

    // optional int32 fl_increase_overhead_offset = 7;
    if (has_fl_increase_overhead_offset()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->fl_increase_overhead_offset());
    }

    // optional int32 fl_decrease_overhead_offset = 8;
    if (has_fl_decrease_overhead_offset()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->fl_decrease_overhead_offset());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void FrameLengthController::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const FrameLengthController*>(&from));
}

void FrameLengthController::MergeFrom(const FrameLengthController& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.FrameLengthController)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      fl_increasing_packet_loss_fraction_ = from.fl_increasing_packet_loss_fraction_;
    }
    if (cached_has_bits & 0x00000002u) {
      fl_decreasing_packet_loss_fraction_ = from.fl_decreasing_packet_loss_fraction_;
    }
    if (cached_has_bits & 0x00000004u) {
      fl_20ms_to_60ms_bandwidth_bps_ = from.fl_20ms_to_60ms_bandwidth_bps_;
    }
    if (cached_has_bits & 0x00000008u) {
      fl_60ms_to_20ms_bandwidth_bps_ = from.fl_60ms_to_20ms_bandwidth_bps_;
    }
    if (cached_has_bits & 0x00000010u) {
      fl_60ms_to_120ms_bandwidth_bps_ = from.fl_60ms_to_120ms_bandwidth_bps_;
    }
    if (cached_has_bits & 0x00000020u) {
      fl_120ms_to_60ms_bandwidth_bps_ = from.fl_120ms_to_60ms_bandwidth_bps_;
    }
    if (cached_has_bits & 0x00000040u) {
      fl_increase_overhead_offset_ = from.fl_increase_overhead_offset_;
    }
    if (cached_has_bits & 0x00000080u) {
      fl_decrease_overhead_offset_ = from.fl_decrease_overhead_offset_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void FrameLengthController::CopyFrom(const FrameLengthController& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.FrameLengthController)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool FrameLengthController::IsInitialized() const {
  return true;
}

void FrameLengthController::Swap(FrameLengthController* other) {
  if (other == this) return;
  InternalSwap(other);
}
void FrameLengthController::InternalSwap(FrameLengthController* other) {
  std::swap(fl_increasing_packet_loss_fraction_, other->fl_increasing_packet_loss_fraction_);
  std::swap(fl_decreasing_packet_loss_fraction_, other->fl_decreasing_packet_loss_fraction_);
  std::swap(fl_20ms_to_60ms_bandwidth_bps_, other->fl_20ms_to_60ms_bandwidth_bps_);
  std::swap(fl_60ms_to_20ms_bandwidth_bps_, other->fl_60ms_to_20ms_bandwidth_bps_);
  std::swap(fl_60ms_to_120ms_bandwidth_bps_, other->fl_60ms_to_120ms_bandwidth_bps_);
  std::swap(fl_120ms_to_60ms_bandwidth_bps_, other->fl_120ms_to_60ms_bandwidth_bps_);
  std::swap(fl_increase_overhead_offset_, other->fl_increase_overhead_offset_);
  std::swap(fl_decrease_overhead_offset_, other->fl_decrease_overhead_offset_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string FrameLengthController::GetTypeName() const {
  return "webrtc.audio_network_adaptor.config.FrameLengthController";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// FrameLengthController

// optional float fl_increasing_packet_loss_fraction = 1;
bool FrameLengthController::has_fl_increasing_packet_loss_fraction() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void FrameLengthController::set_has_fl_increasing_packet_loss_fraction() {
  _has_bits_[0] |= 0x00000001u;
}
void FrameLengthController::clear_has_fl_increasing_packet_loss_fraction() {
  _has_bits_[0] &= ~0x00000001u;
}
void FrameLengthController::clear_fl_increasing_packet_loss_fraction() {
  fl_increasing_packet_loss_fraction_ = 0;
  clear_has_fl_increasing_packet_loss_fraction();
}
float FrameLengthController::fl_increasing_packet_loss_fraction() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.FrameLengthController.fl_increasing_packet_loss_fraction)
  return fl_increasing_packet_loss_fraction_;
}
void FrameLengthController::set_fl_increasing_packet_loss_fraction(float value) {
  set_has_fl_increasing_packet_loss_fraction();
  fl_increasing_packet_loss_fraction_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.FrameLengthController.fl_increasing_packet_loss_fraction)
}

// optional float fl_decreasing_packet_loss_fraction = 2;
bool FrameLengthController::has_fl_decreasing_packet_loss_fraction() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void FrameLengthController::set_has_fl_decreasing_packet_loss_fraction() {
  _has_bits_[0] |= 0x00000002u;
}
void FrameLengthController::clear_has_fl_decreasing_packet_loss_fraction() {
  _has_bits_[0] &= ~0x00000002u;
}
void FrameLengthController::clear_fl_decreasing_packet_loss_fraction() {
  fl_decreasing_packet_loss_fraction_ = 0;
  clear_has_fl_decreasing_packet_loss_fraction();
}
float FrameLengthController::fl_decreasing_packet_loss_fraction() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.FrameLengthController.fl_decreasing_packet_loss_fraction)
  return fl_decreasing_packet_loss_fraction_;
}
void FrameLengthController::set_fl_decreasing_packet_loss_fraction(float value) {
  set_has_fl_decreasing_packet_loss_fraction();
  fl_decreasing_packet_loss_fraction_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.FrameLengthController.fl_decreasing_packet_loss_fraction)
}

// optional int32 fl_20ms_to_60ms_bandwidth_bps = 3;
bool FrameLengthController::has_fl_20ms_to_60ms_bandwidth_bps() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void FrameLengthController::set_has_fl_20ms_to_60ms_bandwidth_bps() {
  _has_bits_[0] |= 0x00000004u;
}
void FrameLengthController::clear_has_fl_20ms_to_60ms_bandwidth_bps() {
  _has_bits_[0] &= ~0x00000004u;
}
void FrameLengthController::clear_fl_20ms_to_60ms_bandwidth_bps() {
  fl_20ms_to_60ms_bandwidth_bps_ = 0;
  clear_has_fl_20ms_to_60ms_bandwidth_bps();
}
::google::protobuf::int32 FrameLengthController::fl_20ms_to_60ms_bandwidth_bps() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.FrameLengthController.fl_20ms_to_60ms_bandwidth_bps)
  return fl_20ms_to_60ms_bandwidth_bps_;
}
void FrameLengthController::set_fl_20ms_to_60ms_bandwidth_bps(::google::protobuf::int32 value) {
  set_has_fl_20ms_to_60ms_bandwidth_bps();
  fl_20ms_to_60ms_bandwidth_bps_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.FrameLengthController.fl_20ms_to_60ms_bandwidth_bps)
}

// optional int32 fl_60ms_to_20ms_bandwidth_bps = 4;
bool FrameLengthController::has_fl_60ms_to_20ms_bandwidth_bps() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void FrameLengthController::set_has_fl_60ms_to_20ms_bandwidth_bps() {
  _has_bits_[0] |= 0x00000008u;
}
void FrameLengthController::clear_has_fl_60ms_to_20ms_bandwidth_bps() {
  _has_bits_[0] &= ~0x00000008u;
}
void FrameLengthController::clear_fl_60ms_to_20ms_bandwidth_bps() {
  fl_60ms_to_20ms_bandwidth_bps_ = 0;
  clear_has_fl_60ms_to_20ms_bandwidth_bps();
}
::google::protobuf::int32 FrameLengthController::fl_60ms_to_20ms_bandwidth_bps() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.FrameLengthController.fl_60ms_to_20ms_bandwidth_bps)
  return fl_60ms_to_20ms_bandwidth_bps_;
}
void FrameLengthController::set_fl_60ms_to_20ms_bandwidth_bps(::google::protobuf::int32 value) {
  set_has_fl_60ms_to_20ms_bandwidth_bps();
  fl_60ms_to_20ms_bandwidth_bps_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.FrameLengthController.fl_60ms_to_20ms_bandwidth_bps)
}

// optional int32 fl_60ms_to_120ms_bandwidth_bps = 5;
bool FrameLengthController::has_fl_60ms_to_120ms_bandwidth_bps() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void FrameLengthController::set_has_fl_60ms_to_120ms_bandwidth_bps() {
  _has_bits_[0] |= 0x00000010u;
}
void FrameLengthController::clear_has_fl_60ms_to_120ms_bandwidth_bps() {
  _has_bits_[0] &= ~0x00000010u;
}
void FrameLengthController::clear_fl_60ms_to_120ms_bandwidth_bps() {
  fl_60ms_to_120ms_bandwidth_bps_ = 0;
  clear_has_fl_60ms_to_120ms_bandwidth_bps();
}
::google::protobuf::int32 FrameLengthController::fl_60ms_to_120ms_bandwidth_bps() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.FrameLengthController.fl_60ms_to_120ms_bandwidth_bps)
  return fl_60ms_to_120ms_bandwidth_bps_;
}
void FrameLengthController::set_fl_60ms_to_120ms_bandwidth_bps(::google::protobuf::int32 value) {
  set_has_fl_60ms_to_120ms_bandwidth_bps();
  fl_60ms_to_120ms_bandwidth_bps_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.FrameLengthController.fl_60ms_to_120ms_bandwidth_bps)
}

// optional int32 fl_120ms_to_60ms_bandwidth_bps = 6;
bool FrameLengthController::has_fl_120ms_to_60ms_bandwidth_bps() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void FrameLengthController::set_has_fl_120ms_to_60ms_bandwidth_bps() {
  _has_bits_[0] |= 0x00000020u;
}
void FrameLengthController::clear_has_fl_120ms_to_60ms_bandwidth_bps() {
  _has_bits_[0] &= ~0x00000020u;
}
void FrameLengthController::clear_fl_120ms_to_60ms_bandwidth_bps() {
  fl_120ms_to_60ms_bandwidth_bps_ = 0;
  clear_has_fl_120ms_to_60ms_bandwidth_bps();
}
::google::protobuf::int32 FrameLengthController::fl_120ms_to_60ms_bandwidth_bps() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.FrameLengthController.fl_120ms_to_60ms_bandwidth_bps)
  return fl_120ms_to_60ms_bandwidth_bps_;
}
void FrameLengthController::set_fl_120ms_to_60ms_bandwidth_bps(::google::protobuf::int32 value) {
  set_has_fl_120ms_to_60ms_bandwidth_bps();
  fl_120ms_to_60ms_bandwidth_bps_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.FrameLengthController.fl_120ms_to_60ms_bandwidth_bps)
}

// optional int32 fl_increase_overhead_offset = 7;
bool FrameLengthController::has_fl_increase_overhead_offset() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void FrameLengthController::set_has_fl_increase_overhead_offset() {
  _has_bits_[0] |= 0x00000040u;
}
void FrameLengthController::clear_has_fl_increase_overhead_offset() {
  _has_bits_[0] &= ~0x00000040u;
}
void FrameLengthController::clear_fl_increase_overhead_offset() {
  fl_increase_overhead_offset_ = 0;
  clear_has_fl_increase_overhead_offset();
}
::google::protobuf::int32 FrameLengthController::fl_increase_overhead_offset() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.FrameLengthController.fl_increase_overhead_offset)
  return fl_increase_overhead_offset_;
}
void FrameLengthController::set_fl_increase_overhead_offset(::google::protobuf::int32 value) {
  set_has_fl_increase_overhead_offset();
  fl_increase_overhead_offset_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.FrameLengthController.fl_increase_overhead_offset)
}

// optional int32 fl_decrease_overhead_offset = 8;
bool FrameLengthController::has_fl_decrease_overhead_offset() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
void FrameLengthController::set_has_fl_decrease_overhead_offset() {
  _has_bits_[0] |= 0x00000080u;
}
void FrameLengthController::clear_has_fl_decrease_overhead_offset() {
  _has_bits_[0] &= ~0x00000080u;
}
void FrameLengthController::clear_fl_decrease_overhead_offset() {
  fl_decrease_overhead_offset_ = 0;
  clear_has_fl_decrease_overhead_offset();
}
::google::protobuf::int32 FrameLengthController::fl_decrease_overhead_offset() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.FrameLengthController.fl_decrease_overhead_offset)
  return fl_decrease_overhead_offset_;
}
void FrameLengthController::set_fl_decrease_overhead_offset(::google::protobuf::int32 value) {
  set_has_fl_decrease_overhead_offset();
  fl_decrease_overhead_offset_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.FrameLengthController.fl_decrease_overhead_offset)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ChannelController::kChannel1To2BandwidthBpsFieldNumber;
const int ChannelController::kChannel2To1BandwidthBpsFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ChannelController::ChannelController()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_config_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.audio_network_adaptor.config.ChannelController)
}
ChannelController::ChannelController(const ChannelController& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&channel_1_to_2_bandwidth_bps_, &from.channel_1_to_2_bandwidth_bps_,
    static_cast<size_t>(reinterpret_cast<char*>(&channel_2_to_1_bandwidth_bps_) -
    reinterpret_cast<char*>(&channel_1_to_2_bandwidth_bps_)) + sizeof(channel_2_to_1_bandwidth_bps_));
  // @@protoc_insertion_point(copy_constructor:webrtc.audio_network_adaptor.config.ChannelController)
}

void ChannelController::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&channel_1_to_2_bandwidth_bps_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&channel_2_to_1_bandwidth_bps_) -
      reinterpret_cast<char*>(&channel_1_to_2_bandwidth_bps_)) + sizeof(channel_2_to_1_bandwidth_bps_));
}

ChannelController::~ChannelController() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.ChannelController)
  SharedDtor();
}

void ChannelController::SharedDtor() {
}

void ChannelController::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ChannelController& ChannelController::default_instance() {
  protobuf_config_2eproto::InitDefaults();
  return *internal_default_instance();
}

ChannelController* ChannelController::New(::google::protobuf::Arena* arena) const {
  ChannelController* n = new ChannelController;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ChannelController::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.ChannelController)
  if (_has_bits_[0 / 32] & 3u) {
    ::memset(&channel_1_to_2_bandwidth_bps_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&channel_2_to_1_bandwidth_bps_) -
        reinterpret_cast<char*>(&channel_1_to_2_bandwidth_bps_)) + sizeof(channel_2_to_1_bandwidth_bps_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ChannelController::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:webrtc.audio_network_adaptor.config.ChannelController)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 channel_1_to_2_bandwidth_bps = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_channel_1_to_2_bandwidth_bps();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &channel_1_to_2_bandwidth_bps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 channel_2_to_1_bandwidth_bps = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_channel_2_to_1_bandwidth_bps();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &channel_2_to_1_bandwidth_bps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.audio_network_adaptor.config.ChannelController)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.audio_network_adaptor.config.ChannelController)
  return false;
#undef DO_
}

void ChannelController::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.audio_network_adaptor.config.ChannelController)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 channel_1_to_2_bandwidth_bps = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->channel_1_to_2_bandwidth_bps(), output);
  }

  // optional int32 channel_2_to_1_bandwidth_bps = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->channel_2_to_1_bandwidth_bps(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:webrtc.audio_network_adaptor.config.ChannelController)
}

size_t ChannelController::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.ChannelController)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 3u) {
    // optional int32 channel_1_to_2_bandwidth_bps = 1;
    if (has_channel_1_to_2_bandwidth_bps()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->channel_1_to_2_bandwidth_bps());
    }

    // optional int32 channel_2_to_1_bandwidth_bps = 2;
    if (has_channel_2_to_1_bandwidth_bps()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->channel_2_to_1_bandwidth_bps());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ChannelController::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ChannelController*>(&from));
}

void ChannelController::MergeFrom(const ChannelController& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.ChannelController)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      channel_1_to_2_bandwidth_bps_ = from.channel_1_to_2_bandwidth_bps_;
    }
    if (cached_has_bits & 0x00000002u) {
      channel_2_to_1_bandwidth_bps_ = from.channel_2_to_1_bandwidth_bps_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ChannelController::CopyFrom(const ChannelController& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.ChannelController)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ChannelController::IsInitialized() const {
  return true;
}

void ChannelController::Swap(ChannelController* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ChannelController::InternalSwap(ChannelController* other) {
  std::swap(channel_1_to_2_bandwidth_bps_, other->channel_1_to_2_bandwidth_bps_);
  std::swap(channel_2_to_1_bandwidth_bps_, other->channel_2_to_1_bandwidth_bps_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string ChannelController::GetTypeName() const {
  return "webrtc.audio_network_adaptor.config.ChannelController";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// ChannelController

// optional int32 channel_1_to_2_bandwidth_bps = 1;
bool ChannelController::has_channel_1_to_2_bandwidth_bps() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void ChannelController::set_has_channel_1_to_2_bandwidth_bps() {
  _has_bits_[0] |= 0x00000001u;
}
void ChannelController::clear_has_channel_1_to_2_bandwidth_bps() {
  _has_bits_[0] &= ~0x00000001u;
}
void ChannelController::clear_channel_1_to_2_bandwidth_bps() {
  channel_1_to_2_bandwidth_bps_ = 0;
  clear_has_channel_1_to_2_bandwidth_bps();
}
::google::protobuf::int32 ChannelController::channel_1_to_2_bandwidth_bps() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.ChannelController.channel_1_to_2_bandwidth_bps)
  return channel_1_to_2_bandwidth_bps_;
}
void ChannelController::set_channel_1_to_2_bandwidth_bps(::google::protobuf::int32 value) {
  set_has_channel_1_to_2_bandwidth_bps();
  channel_1_to_2_bandwidth_bps_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.ChannelController.channel_1_to_2_bandwidth_bps)
}

// optional int32 channel_2_to_1_bandwidth_bps = 2;
bool ChannelController::has_channel_2_to_1_bandwidth_bps() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void ChannelController::set_has_channel_2_to_1_bandwidth_bps() {
  _has_bits_[0] |= 0x00000002u;
}
void ChannelController::clear_has_channel_2_to_1_bandwidth_bps() {
  _has_bits_[0] &= ~0x00000002u;
}
void ChannelController::clear_channel_2_to_1_bandwidth_bps() {
  channel_2_to_1_bandwidth_bps_ = 0;
  clear_has_channel_2_to_1_bandwidth_bps();
}
::google::protobuf::int32 ChannelController::channel_2_to_1_bandwidth_bps() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.ChannelController.channel_2_to_1_bandwidth_bps)
  return channel_2_to_1_bandwidth_bps_;
}
void ChannelController::set_channel_2_to_1_bandwidth_bps(::google::protobuf::int32 value) {
  set_has_channel_2_to_1_bandwidth_bps();
  channel_2_to_1_bandwidth_bps_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.ChannelController.channel_2_to_1_bandwidth_bps)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int DtxController::kDtxEnablingBandwidthBpsFieldNumber;
const int DtxController::kDtxDisablingBandwidthBpsFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

DtxController::DtxController()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_config_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.audio_network_adaptor.config.DtxController)
}
DtxController::DtxController(const DtxController& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&dtx_enabling_bandwidth_bps_, &from.dtx_enabling_bandwidth_bps_,
    static_cast<size_t>(reinterpret_cast<char*>(&dtx_disabling_bandwidth_bps_) -
    reinterpret_cast<char*>(&dtx_enabling_bandwidth_bps_)) + sizeof(dtx_disabling_bandwidth_bps_));
  // @@protoc_insertion_point(copy_constructor:webrtc.audio_network_adaptor.config.DtxController)
}

void DtxController::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&dtx_enabling_bandwidth_bps_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&dtx_disabling_bandwidth_bps_) -
      reinterpret_cast<char*>(&dtx_enabling_bandwidth_bps_)) + sizeof(dtx_disabling_bandwidth_bps_));
}

DtxController::~DtxController() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.DtxController)
  SharedDtor();
}

void DtxController::SharedDtor() {
}

void DtxController::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const DtxController& DtxController::default_instance() {
  protobuf_config_2eproto::InitDefaults();
  return *internal_default_instance();
}

DtxController* DtxController::New(::google::protobuf::Arena* arena) const {
  DtxController* n = new DtxController;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void DtxController::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.DtxController)
  if (_has_bits_[0 / 32] & 3u) {
    ::memset(&dtx_enabling_bandwidth_bps_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&dtx_disabling_bandwidth_bps_) -
        reinterpret_cast<char*>(&dtx_enabling_bandwidth_bps_)) + sizeof(dtx_disabling_bandwidth_bps_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool DtxController::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:webrtc.audio_network_adaptor.config.DtxController)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 dtx_enabling_bandwidth_bps = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_dtx_enabling_bandwidth_bps();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &dtx_enabling_bandwidth_bps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 dtx_disabling_bandwidth_bps = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_dtx_disabling_bandwidth_bps();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &dtx_disabling_bandwidth_bps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.audio_network_adaptor.config.DtxController)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.audio_network_adaptor.config.DtxController)
  return false;
#undef DO_
}

void DtxController::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.audio_network_adaptor.config.DtxController)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 dtx_enabling_bandwidth_bps = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->dtx_enabling_bandwidth_bps(), output);
  }

  // optional int32 dtx_disabling_bandwidth_bps = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->dtx_disabling_bandwidth_bps(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:webrtc.audio_network_adaptor.config.DtxController)
}

size_t DtxController::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.DtxController)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 3u) {
    // optional int32 dtx_enabling_bandwidth_bps = 1;
    if (has_dtx_enabling_bandwidth_bps()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->dtx_enabling_bandwidth_bps());
    }

    // optional int32 dtx_disabling_bandwidth_bps = 2;
    if (has_dtx_disabling_bandwidth_bps()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->dtx_disabling_bandwidth_bps());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DtxController::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const DtxController*>(&from));
}

void DtxController::MergeFrom(const DtxController& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.DtxController)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      dtx_enabling_bandwidth_bps_ = from.dtx_enabling_bandwidth_bps_;
    }
    if (cached_has_bits & 0x00000002u) {
      dtx_disabling_bandwidth_bps_ = from.dtx_disabling_bandwidth_bps_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void DtxController::CopyFrom(const DtxController& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.DtxController)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DtxController::IsInitialized() const {
  return true;
}

void DtxController::Swap(DtxController* other) {
  if (other == this) return;
  InternalSwap(other);
}
void DtxController::InternalSwap(DtxController* other) {
  std::swap(dtx_enabling_bandwidth_bps_, other->dtx_enabling_bandwidth_bps_);
  std::swap(dtx_disabling_bandwidth_bps_, other->dtx_disabling_bandwidth_bps_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string DtxController::GetTypeName() const {
  return "webrtc.audio_network_adaptor.config.DtxController";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// DtxController

// optional int32 dtx_enabling_bandwidth_bps = 1;
bool DtxController::has_dtx_enabling_bandwidth_bps() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void DtxController::set_has_dtx_enabling_bandwidth_bps() {
  _has_bits_[0] |= 0x00000001u;
}
void DtxController::clear_has_dtx_enabling_bandwidth_bps() {
  _has_bits_[0] &= ~0x00000001u;
}
void DtxController::clear_dtx_enabling_bandwidth_bps() {
  dtx_enabling_bandwidth_bps_ = 0;
  clear_has_dtx_enabling_bandwidth_bps();
}
::google::protobuf::int32 DtxController::dtx_enabling_bandwidth_bps() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.DtxController.dtx_enabling_bandwidth_bps)
  return dtx_enabling_bandwidth_bps_;
}
void DtxController::set_dtx_enabling_bandwidth_bps(::google::protobuf::int32 value) {
  set_has_dtx_enabling_bandwidth_bps();
  dtx_enabling_bandwidth_bps_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.DtxController.dtx_enabling_bandwidth_bps)
}

// optional int32 dtx_disabling_bandwidth_bps = 2;
bool DtxController::has_dtx_disabling_bandwidth_bps() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void DtxController::set_has_dtx_disabling_bandwidth_bps() {
  _has_bits_[0] |= 0x00000002u;
}
void DtxController::clear_has_dtx_disabling_bandwidth_bps() {
  _has_bits_[0] &= ~0x00000002u;
}
void DtxController::clear_dtx_disabling_bandwidth_bps() {
  dtx_disabling_bandwidth_bps_ = 0;
  clear_has_dtx_disabling_bandwidth_bps();
}
::google::protobuf::int32 DtxController::dtx_disabling_bandwidth_bps() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.DtxController.dtx_disabling_bandwidth_bps)
  return dtx_disabling_bandwidth_bps_;
}
void DtxController::set_dtx_disabling_bandwidth_bps(::google::protobuf::int32 value) {
  set_has_dtx_disabling_bandwidth_bps();
  dtx_disabling_bandwidth_bps_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.DtxController.dtx_disabling_bandwidth_bps)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int BitrateController::kFlIncreaseOverheadOffsetFieldNumber;
const int BitrateController::kFlDecreaseOverheadOffsetFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

BitrateController::BitrateController()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_config_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.audio_network_adaptor.config.BitrateController)
}
BitrateController::BitrateController(const BitrateController& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&fl_increase_overhead_offset_, &from.fl_increase_overhead_offset_,
    static_cast<size_t>(reinterpret_cast<char*>(&fl_decrease_overhead_offset_) -
    reinterpret_cast<char*>(&fl_increase_overhead_offset_)) + sizeof(fl_decrease_overhead_offset_));
  // @@protoc_insertion_point(copy_constructor:webrtc.audio_network_adaptor.config.BitrateController)
}

void BitrateController::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&fl_increase_overhead_offset_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&fl_decrease_overhead_offset_) -
      reinterpret_cast<char*>(&fl_increase_overhead_offset_)) + sizeof(fl_decrease_overhead_offset_));
}

BitrateController::~BitrateController() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.BitrateController)
  SharedDtor();
}

void BitrateController::SharedDtor() {
}

void BitrateController::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const BitrateController& BitrateController::default_instance() {
  protobuf_config_2eproto::InitDefaults();
  return *internal_default_instance();
}

BitrateController* BitrateController::New(::google::protobuf::Arena* arena) const {
  BitrateController* n = new BitrateController;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void BitrateController::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.BitrateController)
  if (_has_bits_[0 / 32] & 3u) {
    ::memset(&fl_increase_overhead_offset_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&fl_decrease_overhead_offset_) -
        reinterpret_cast<char*>(&fl_increase_overhead_offset_)) + sizeof(fl_decrease_overhead_offset_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool BitrateController::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:webrtc.audio_network_adaptor.config.BitrateController)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 fl_increase_overhead_offset = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_fl_increase_overhead_offset();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &fl_increase_overhead_offset_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 fl_decrease_overhead_offset = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_fl_decrease_overhead_offset();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &fl_decrease_overhead_offset_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.audio_network_adaptor.config.BitrateController)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.audio_network_adaptor.config.BitrateController)
  return false;
#undef DO_
}

void BitrateController::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.audio_network_adaptor.config.BitrateController)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 fl_increase_overhead_offset = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->fl_increase_overhead_offset(), output);
  }

  // optional int32 fl_decrease_overhead_offset = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->fl_decrease_overhead_offset(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:webrtc.audio_network_adaptor.config.BitrateController)
}

size_t BitrateController::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.BitrateController)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 3u) {
    // optional int32 fl_increase_overhead_offset = 1;
    if (has_fl_increase_overhead_offset()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->fl_increase_overhead_offset());
    }

    // optional int32 fl_decrease_overhead_offset = 2;
    if (has_fl_decrease_overhead_offset()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->fl_decrease_overhead_offset());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void BitrateController::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const BitrateController*>(&from));
}

void BitrateController::MergeFrom(const BitrateController& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.BitrateController)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      fl_increase_overhead_offset_ = from.fl_increase_overhead_offset_;
    }
    if (cached_has_bits & 0x00000002u) {
      fl_decrease_overhead_offset_ = from.fl_decrease_overhead_offset_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void BitrateController::CopyFrom(const BitrateController& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.BitrateController)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BitrateController::IsInitialized() const {
  return true;
}

void BitrateController::Swap(BitrateController* other) {
  if (other == this) return;
  InternalSwap(other);
}
void BitrateController::InternalSwap(BitrateController* other) {
  std::swap(fl_increase_overhead_offset_, other->fl_increase_overhead_offset_);
  std::swap(fl_decrease_overhead_offset_, other->fl_decrease_overhead_offset_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string BitrateController::GetTypeName() const {
  return "webrtc.audio_network_adaptor.config.BitrateController";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// BitrateController

// optional int32 fl_increase_overhead_offset = 1;
bool BitrateController::has_fl_increase_overhead_offset() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void BitrateController::set_has_fl_increase_overhead_offset() {
  _has_bits_[0] |= 0x00000001u;
}
void BitrateController::clear_has_fl_increase_overhead_offset() {
  _has_bits_[0] &= ~0x00000001u;
}
void BitrateController::clear_fl_increase_overhead_offset() {
  fl_increase_overhead_offset_ = 0;
  clear_has_fl_increase_overhead_offset();
}
::google::protobuf::int32 BitrateController::fl_increase_overhead_offset() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.BitrateController.fl_increase_overhead_offset)
  return fl_increase_overhead_offset_;
}
void BitrateController::set_fl_increase_overhead_offset(::google::protobuf::int32 value) {
  set_has_fl_increase_overhead_offset();
  fl_increase_overhead_offset_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.BitrateController.fl_increase_overhead_offset)
}

// optional int32 fl_decrease_overhead_offset = 2;
bool BitrateController::has_fl_decrease_overhead_offset() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void BitrateController::set_has_fl_decrease_overhead_offset() {
  _has_bits_[0] |= 0x00000002u;
}
void BitrateController::clear_has_fl_decrease_overhead_offset() {
  _has_bits_[0] &= ~0x00000002u;
}
void BitrateController::clear_fl_decrease_overhead_offset() {
  fl_decrease_overhead_offset_ = 0;
  clear_has_fl_decrease_overhead_offset();
}
::google::protobuf::int32 BitrateController::fl_decrease_overhead_offset() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.BitrateController.fl_decrease_overhead_offset)
  return fl_decrease_overhead_offset_;
}
void BitrateController::set_fl_decrease_overhead_offset(::google::protobuf::int32 value) {
  set_has_fl_decrease_overhead_offset();
  fl_decrease_overhead_offset_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.BitrateController.fl_decrease_overhead_offset)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int Controller_ScoringPoint::kUplinkBandwidthBpsFieldNumber;
const int Controller_ScoringPoint::kUplinkPacketLossFractionFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

Controller_ScoringPoint::Controller_ScoringPoint()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_config_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.audio_network_adaptor.config.Controller.ScoringPoint)
}
Controller_ScoringPoint::Controller_ScoringPoint(const Controller_ScoringPoint& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&uplink_bandwidth_bps_, &from.uplink_bandwidth_bps_,
    static_cast<size_t>(reinterpret_cast<char*>(&uplink_packet_loss_fraction_) -
    reinterpret_cast<char*>(&uplink_bandwidth_bps_)) + sizeof(uplink_packet_loss_fraction_));
  // @@protoc_insertion_point(copy_constructor:webrtc.audio_network_adaptor.config.Controller.ScoringPoint)
}

void Controller_ScoringPoint::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&uplink_bandwidth_bps_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&uplink_packet_loss_fraction_) -
      reinterpret_cast<char*>(&uplink_bandwidth_bps_)) + sizeof(uplink_packet_loss_fraction_));
}

Controller_ScoringPoint::~Controller_ScoringPoint() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.Controller.ScoringPoint)
  SharedDtor();
}

void Controller_ScoringPoint::SharedDtor() {
}

void Controller_ScoringPoint::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const Controller_ScoringPoint& Controller_ScoringPoint::default_instance() {
  protobuf_config_2eproto::InitDefaults();
  return *internal_default_instance();
}

Controller_ScoringPoint* Controller_ScoringPoint::New(::google::protobuf::Arena* arena) const {
  Controller_ScoringPoint* n = new Controller_ScoringPoint;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void Controller_ScoringPoint::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.Controller.ScoringPoint)
  if (_has_bits_[0 / 32] & 3u) {
    ::memset(&uplink_bandwidth_bps_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&uplink_packet_loss_fraction_) -
        reinterpret_cast<char*>(&uplink_bandwidth_bps_)) + sizeof(uplink_packet_loss_fraction_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool Controller_ScoringPoint::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:webrtc.audio_network_adaptor.config.Controller.ScoringPoint)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 uplink_bandwidth_bps = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_uplink_bandwidth_bps();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &uplink_bandwidth_bps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float uplink_packet_loss_fraction = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(21u)) {
          set_has_uplink_packet_loss_fraction();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &uplink_packet_loss_fraction_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.audio_network_adaptor.config.Controller.ScoringPoint)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.audio_network_adaptor.config.Controller.ScoringPoint)
  return false;
#undef DO_
}

void Controller_ScoringPoint::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.audio_network_adaptor.config.Controller.ScoringPoint)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 uplink_bandwidth_bps = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->uplink_bandwidth_bps(), output);
  }

  // optional float uplink_packet_loss_fraction = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->uplink_packet_loss_fraction(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:webrtc.audio_network_adaptor.config.Controller.ScoringPoint)
}

size_t Controller_ScoringPoint::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.Controller.ScoringPoint)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 3u) {
    // optional int32 uplink_bandwidth_bps = 1;
    if (has_uplink_bandwidth_bps()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->uplink_bandwidth_bps());
    }

    // optional float uplink_packet_loss_fraction = 2;
    if (has_uplink_packet_loss_fraction()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Controller_ScoringPoint::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const Controller_ScoringPoint*>(&from));
}

void Controller_ScoringPoint::MergeFrom(const Controller_ScoringPoint& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.Controller.ScoringPoint)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      uplink_bandwidth_bps_ = from.uplink_bandwidth_bps_;
    }
    if (cached_has_bits & 0x00000002u) {
      uplink_packet_loss_fraction_ = from.uplink_packet_loss_fraction_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void Controller_ScoringPoint::CopyFrom(const Controller_ScoringPoint& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.Controller.ScoringPoint)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Controller_ScoringPoint::IsInitialized() const {
  return true;
}

void Controller_ScoringPoint::Swap(Controller_ScoringPoint* other) {
  if (other == this) return;
  InternalSwap(other);
}
void Controller_ScoringPoint::InternalSwap(Controller_ScoringPoint* other) {
  std::swap(uplink_bandwidth_bps_, other->uplink_bandwidth_bps_);
  std::swap(uplink_packet_loss_fraction_, other->uplink_packet_loss_fraction_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string Controller_ScoringPoint::GetTypeName() const {
  return "webrtc.audio_network_adaptor.config.Controller.ScoringPoint";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// Controller_ScoringPoint

// optional int32 uplink_bandwidth_bps = 1;
bool Controller_ScoringPoint::has_uplink_bandwidth_bps() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void Controller_ScoringPoint::set_has_uplink_bandwidth_bps() {
  _has_bits_[0] |= 0x00000001u;
}
void Controller_ScoringPoint::clear_has_uplink_bandwidth_bps() {
  _has_bits_[0] &= ~0x00000001u;
}
void Controller_ScoringPoint::clear_uplink_bandwidth_bps() {
  uplink_bandwidth_bps_ = 0;
  clear_has_uplink_bandwidth_bps();
}
::google::protobuf::int32 Controller_ScoringPoint::uplink_bandwidth_bps() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.Controller.ScoringPoint.uplink_bandwidth_bps)
  return uplink_bandwidth_bps_;
}
void Controller_ScoringPoint::set_uplink_bandwidth_bps(::google::protobuf::int32 value) {
  set_has_uplink_bandwidth_bps();
  uplink_bandwidth_bps_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.Controller.ScoringPoint.uplink_bandwidth_bps)
}

// optional float uplink_packet_loss_fraction = 2;
bool Controller_ScoringPoint::has_uplink_packet_loss_fraction() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void Controller_ScoringPoint::set_has_uplink_packet_loss_fraction() {
  _has_bits_[0] |= 0x00000002u;
}
void Controller_ScoringPoint::clear_has_uplink_packet_loss_fraction() {
  _has_bits_[0] &= ~0x00000002u;
}
void Controller_ScoringPoint::clear_uplink_packet_loss_fraction() {
  uplink_packet_loss_fraction_ = 0;
  clear_has_uplink_packet_loss_fraction();
}
float Controller_ScoringPoint::uplink_packet_loss_fraction() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.Controller.ScoringPoint.uplink_packet_loss_fraction)
  return uplink_packet_loss_fraction_;
}
void Controller_ScoringPoint::set_uplink_packet_loss_fraction(float value) {
  set_has_uplink_packet_loss_fraction();
  uplink_packet_loss_fraction_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.Controller.ScoringPoint.uplink_packet_loss_fraction)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int Controller::kScoringPointFieldNumber;
const int Controller::kFecControllerFieldNumber;
const int Controller::kFrameLengthControllerFieldNumber;
const int Controller::kChannelControllerFieldNumber;
const int Controller::kDtxControllerFieldNumber;
const int Controller::kBitrateControllerFieldNumber;
const int Controller::kFecControllerRplrBasedFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

Controller::Controller()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_config_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.audio_network_adaptor.config.Controller)
}
Controller::Controller(const Controller& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_scoring_point()) {
    scoring_point_ = new ::webrtc::audio_network_adaptor::config::Controller_ScoringPoint(*from.scoring_point_);
  } else {
    scoring_point_ = NULL;
  }
  clear_has_controller();
  switch (from.controller_case()) {
    case kFecController: {
      mutable_fec_controller()->::webrtc::audio_network_adaptor::config::FecController::MergeFrom(from.fec_controller());
      break;
    }
    case kFrameLengthController: {
      mutable_frame_length_controller()->::webrtc::audio_network_adaptor::config::FrameLengthController::MergeFrom(from.frame_length_controller());
      break;
    }
    case kChannelController: {
      mutable_channel_controller()->::webrtc::audio_network_adaptor::config::ChannelController::MergeFrom(from.channel_controller());
      break;
    }
    case kDtxController: {
      mutable_dtx_controller()->::webrtc::audio_network_adaptor::config::DtxController::MergeFrom(from.dtx_controller());
      break;
    }
    case kBitrateController: {
      mutable_bitrate_controller()->::webrtc::audio_network_adaptor::config::BitrateController::MergeFrom(from.bitrate_controller());
      break;
    }
    case kFecControllerRplrBased: {
      mutable_fec_controller_rplr_based()->::webrtc::audio_network_adaptor::config::FecControllerRplrBased::MergeFrom(from.fec_controller_rplr_based());
      break;
    }
    case CONTROLLER_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:webrtc.audio_network_adaptor.config.Controller)
}

void Controller::SharedCtor() {
  _cached_size_ = 0;
  scoring_point_ = NULL;
  clear_has_controller();
}

Controller::~Controller() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.Controller)
  SharedDtor();
}

void Controller::SharedDtor() {
  if (this != internal_default_instance()) {
    delete scoring_point_;
  }
  if (has_controller()) {
    clear_controller();
  }
}

void Controller::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const Controller& Controller::default_instance() {
  protobuf_config_2eproto::InitDefaults();
  return *internal_default_instance();
}

Controller* Controller::New(::google::protobuf::Arena* arena) const {
  Controller* n = new Controller;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void Controller::clear_controller() {
// @@protoc_insertion_point(one_of_clear_start:webrtc.audio_network_adaptor.config.Controller)
  switch (controller_case()) {
    case kFecController: {
      delete controller_.fec_controller_;
      break;
    }
    case kFrameLengthController: {
      delete controller_.frame_length_controller_;
      break;
    }
    case kChannelController: {
      delete controller_.channel_controller_;
      break;
    }
    case kDtxController: {
      delete controller_.dtx_controller_;
      break;
    }
    case kBitrateController: {
      delete controller_.bitrate_controller_;
      break;
    }
    case kFecControllerRplrBased: {
      delete controller_.fec_controller_rplr_based_;
      break;
    }
    case CONTROLLER_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = CONTROLLER_NOT_SET;
}


void Controller::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.Controller)
  if (has_scoring_point()) {
    GOOGLE_DCHECK(scoring_point_ != NULL);
    scoring_point_->::webrtc::audio_network_adaptor::config::Controller_ScoringPoint::Clear();
  }
  clear_controller();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool Controller::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:webrtc.audio_network_adaptor.config.Controller)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(16383u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .webrtc.audio_network_adaptor.config.Controller.ScoringPoint scoring_point = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_scoring_point()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.audio_network_adaptor.config.FecController fec_controller = 21;
      case 21: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(170u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_fec_controller()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.audio_network_adaptor.config.FrameLengthController frame_length_controller = 22;
      case 22: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(178u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_frame_length_controller()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.audio_network_adaptor.config.ChannelController channel_controller = 23;
      case 23: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(186u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_channel_controller()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.audio_network_adaptor.config.DtxController dtx_controller = 24;
      case 24: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(194u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_dtx_controller()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.audio_network_adaptor.config.BitrateController bitrate_controller = 25;
      case 25: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(202u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_bitrate_controller()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.audio_network_adaptor.config.FecControllerRplrBased fec_controller_rplr_based = 26;
      case 26: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(210u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_fec_controller_rplr_based()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.audio_network_adaptor.config.Controller)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.audio_network_adaptor.config.Controller)
  return false;
#undef DO_
}

void Controller::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.audio_network_adaptor.config.Controller)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .webrtc.audio_network_adaptor.config.Controller.ScoringPoint scoring_point = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, *this->scoring_point_, output);
  }

  switch (controller_case()) {
    case kFecController:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        21, *controller_.fec_controller_, output);
      break;
    case kFrameLengthController:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        22, *controller_.frame_length_controller_, output);
      break;
    case kChannelController:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        23, *controller_.channel_controller_, output);
      break;
    case kDtxController:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        24, *controller_.dtx_controller_, output);
      break;
    case kBitrateController:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        25, *controller_.bitrate_controller_, output);
      break;
    case kFecControllerRplrBased:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        26, *controller_.fec_controller_rplr_based_, output);
      break;
    default: ;
  }
  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:webrtc.audio_network_adaptor.config.Controller)
}

size_t Controller::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.Controller)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // optional .webrtc.audio_network_adaptor.config.Controller.ScoringPoint scoring_point = 1;
  if (has_scoring_point()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        *this->scoring_point_);
  }

  switch (controller_case()) {
    // optional .webrtc.audio_network_adaptor.config.FecController fec_controller = 21;
    case kFecController: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *controller_.fec_controller_);
      break;
    }
    // optional .webrtc.audio_network_adaptor.config.FrameLengthController frame_length_controller = 22;
    case kFrameLengthController: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *controller_.frame_length_controller_);
      break;
    }
    // optional .webrtc.audio_network_adaptor.config.ChannelController channel_controller = 23;
    case kChannelController: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *controller_.channel_controller_);
      break;
    }
    // optional .webrtc.audio_network_adaptor.config.DtxController dtx_controller = 24;
    case kDtxController: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *controller_.dtx_controller_);
      break;
    }
    // optional .webrtc.audio_network_adaptor.config.BitrateController bitrate_controller = 25;
    case kBitrateController: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *controller_.bitrate_controller_);
      break;
    }
    // optional .webrtc.audio_network_adaptor.config.FecControllerRplrBased fec_controller_rplr_based = 26;
    case kFecControllerRplrBased: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *controller_.fec_controller_rplr_based_);
      break;
    }
    case CONTROLLER_NOT_SET: {
      break;
    }
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Controller::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const Controller*>(&from));
}

void Controller::MergeFrom(const Controller& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.Controller)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_scoring_point()) {
    mutable_scoring_point()->::webrtc::audio_network_adaptor::config::Controller_ScoringPoint::MergeFrom(from.scoring_point());
  }
  switch (from.controller_case()) {
    case kFecController: {
      mutable_fec_controller()->::webrtc::audio_network_adaptor::config::FecController::MergeFrom(from.fec_controller());
      break;
    }
    case kFrameLengthController: {
      mutable_frame_length_controller()->::webrtc::audio_network_adaptor::config::FrameLengthController::MergeFrom(from.frame_length_controller());
      break;
    }
    case kChannelController: {
      mutable_channel_controller()->::webrtc::audio_network_adaptor::config::ChannelController::MergeFrom(from.channel_controller());
      break;
    }
    case kDtxController: {
      mutable_dtx_controller()->::webrtc::audio_network_adaptor::config::DtxController::MergeFrom(from.dtx_controller());
      break;
    }
    case kBitrateController: {
      mutable_bitrate_controller()->::webrtc::audio_network_adaptor::config::BitrateController::MergeFrom(from.bitrate_controller());
      break;
    }
    case kFecControllerRplrBased: {
      mutable_fec_controller_rplr_based()->::webrtc::audio_network_adaptor::config::FecControllerRplrBased::MergeFrom(from.fec_controller_rplr_based());
      break;
    }
    case CONTROLLER_NOT_SET: {
      break;
    }
  }
}

void Controller::CopyFrom(const Controller& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.Controller)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Controller::IsInitialized() const {
  return true;
}

void Controller::Swap(Controller* other) {
  if (other == this) return;
  InternalSwap(other);
}
void Controller::InternalSwap(Controller* other) {
  std::swap(scoring_point_, other->scoring_point_);
  std::swap(controller_, other->controller_);
  std::swap(_oneof_case_[0], other->_oneof_case_[0]);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string Controller::GetTypeName() const {
  return "webrtc.audio_network_adaptor.config.Controller";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// Controller

// optional .webrtc.audio_network_adaptor.config.Controller.ScoringPoint scoring_point = 1;
bool Controller::has_scoring_point() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void Controller::set_has_scoring_point() {
  _has_bits_[0] |= 0x00000001u;
}
void Controller::clear_has_scoring_point() {
  _has_bits_[0] &= ~0x00000001u;
}
void Controller::clear_scoring_point() {
  if (scoring_point_ != NULL) scoring_point_->::webrtc::audio_network_adaptor::config::Controller_ScoringPoint::Clear();
  clear_has_scoring_point();
}
const ::webrtc::audio_network_adaptor::config::Controller_ScoringPoint& Controller::scoring_point() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.Controller.scoring_point)
  return scoring_point_ != NULL ? *scoring_point_
                         : *::webrtc::audio_network_adaptor::config::Controller_ScoringPoint::internal_default_instance();
}
::webrtc::audio_network_adaptor::config::Controller_ScoringPoint* Controller::mutable_scoring_point() {
  set_has_scoring_point();
  if (scoring_point_ == NULL) {
    scoring_point_ = new ::webrtc::audio_network_adaptor::config::Controller_ScoringPoint;
  }
  // @@protoc_insertion_point(field_mutable:webrtc.audio_network_adaptor.config.Controller.scoring_point)
  return scoring_point_;
}
::webrtc::audio_network_adaptor::config::Controller_ScoringPoint* Controller::release_scoring_point() {
  // @@protoc_insertion_point(field_release:webrtc.audio_network_adaptor.config.Controller.scoring_point)
  clear_has_scoring_point();
  ::webrtc::audio_network_adaptor::config::Controller_ScoringPoint* temp = scoring_point_;
  scoring_point_ = NULL;
  return temp;
}
void Controller::set_allocated_scoring_point(::webrtc::audio_network_adaptor::config::Controller_ScoringPoint* scoring_point) {
  delete scoring_point_;
  scoring_point_ = scoring_point;
  if (scoring_point) {
    set_has_scoring_point();
  } else {
    clear_has_scoring_point();
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audio_network_adaptor.config.Controller.scoring_point)
}

// optional .webrtc.audio_network_adaptor.config.FecController fec_controller = 21;
bool Controller::has_fec_controller() const {
  return controller_case() == kFecController;
}
void Controller::set_has_fec_controller() {
  _oneof_case_[0] = kFecController;
}
void Controller::clear_fec_controller() {
  if (has_fec_controller()) {
    delete controller_.fec_controller_;
    clear_has_controller();
  }
}
 const ::webrtc::audio_network_adaptor::config::FecController& Controller::fec_controller() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.Controller.fec_controller)
  return has_fec_controller()
      ? *controller_.fec_controller_
      : ::webrtc::audio_network_adaptor::config::FecController::default_instance();
}
::webrtc::audio_network_adaptor::config::FecController* Controller::mutable_fec_controller() {
  if (!has_fec_controller()) {
    clear_controller();
    set_has_fec_controller();
    controller_.fec_controller_ = new ::webrtc::audio_network_adaptor::config::FecController;
  }
  // @@protoc_insertion_point(field_mutable:webrtc.audio_network_adaptor.config.Controller.fec_controller)
  return controller_.fec_controller_;
}
::webrtc::audio_network_adaptor::config::FecController* Controller::release_fec_controller() {
  // @@protoc_insertion_point(field_release:webrtc.audio_network_adaptor.config.Controller.fec_controller)
  if (has_fec_controller()) {
    clear_has_controller();
    ::webrtc::audio_network_adaptor::config::FecController* temp = controller_.fec_controller_;
    controller_.fec_controller_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void Controller::set_allocated_fec_controller(::webrtc::audio_network_adaptor::config::FecController* fec_controller) {
  clear_controller();
  if (fec_controller) {
    set_has_fec_controller();
    controller_.fec_controller_ = fec_controller;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audio_network_adaptor.config.Controller.fec_controller)
}

// optional .webrtc.audio_network_adaptor.config.FrameLengthController frame_length_controller = 22;
bool Controller::has_frame_length_controller() const {
  return controller_case() == kFrameLengthController;
}
void Controller::set_has_frame_length_controller() {
  _oneof_case_[0] = kFrameLengthController;
}
void Controller::clear_frame_length_controller() {
  if (has_frame_length_controller()) {
    delete controller_.frame_length_controller_;
    clear_has_controller();
  }
}
 const ::webrtc::audio_network_adaptor::config::FrameLengthController& Controller::frame_length_controller() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.Controller.frame_length_controller)
  return has_frame_length_controller()
      ? *controller_.frame_length_controller_
      : ::webrtc::audio_network_adaptor::config::FrameLengthController::default_instance();
}
::webrtc::audio_network_adaptor::config::FrameLengthController* Controller::mutable_frame_length_controller() {
  if (!has_frame_length_controller()) {
    clear_controller();
    set_has_frame_length_controller();
    controller_.frame_length_controller_ = new ::webrtc::audio_network_adaptor::config::FrameLengthController;
  }
  // @@protoc_insertion_point(field_mutable:webrtc.audio_network_adaptor.config.Controller.frame_length_controller)
  return controller_.frame_length_controller_;
}
::webrtc::audio_network_adaptor::config::FrameLengthController* Controller::release_frame_length_controller() {
  // @@protoc_insertion_point(field_release:webrtc.audio_network_adaptor.config.Controller.frame_length_controller)
  if (has_frame_length_controller()) {
    clear_has_controller();
    ::webrtc::audio_network_adaptor::config::FrameLengthController* temp = controller_.frame_length_controller_;
    controller_.frame_length_controller_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void Controller::set_allocated_frame_length_controller(::webrtc::audio_network_adaptor::config::FrameLengthController* frame_length_controller) {
  clear_controller();
  if (frame_length_controller) {
    set_has_frame_length_controller();
    controller_.frame_length_controller_ = frame_length_controller;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audio_network_adaptor.config.Controller.frame_length_controller)
}

// optional .webrtc.audio_network_adaptor.config.ChannelController channel_controller = 23;
bool Controller::has_channel_controller() const {
  return controller_case() == kChannelController;
}
void Controller::set_has_channel_controller() {
  _oneof_case_[0] = kChannelController;
}
void Controller::clear_channel_controller() {
  if (has_channel_controller()) {
    delete controller_.channel_controller_;
    clear_has_controller();
  }
}
 const ::webrtc::audio_network_adaptor::config::ChannelController& Controller::channel_controller() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.Controller.channel_controller)
  return has_channel_controller()
      ? *controller_.channel_controller_
      : ::webrtc::audio_network_adaptor::config::ChannelController::default_instance();
}
::webrtc::audio_network_adaptor::config::ChannelController* Controller::mutable_channel_controller() {
  if (!has_channel_controller()) {
    clear_controller();
    set_has_channel_controller();
    controller_.channel_controller_ = new ::webrtc::audio_network_adaptor::config::ChannelController;
  }
  // @@protoc_insertion_point(field_mutable:webrtc.audio_network_adaptor.config.Controller.channel_controller)
  return controller_.channel_controller_;
}
::webrtc::audio_network_adaptor::config::ChannelController* Controller::release_channel_controller() {
  // @@protoc_insertion_point(field_release:webrtc.audio_network_adaptor.config.Controller.channel_controller)
  if (has_channel_controller()) {
    clear_has_controller();
    ::webrtc::audio_network_adaptor::config::ChannelController* temp = controller_.channel_controller_;
    controller_.channel_controller_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void Controller::set_allocated_channel_controller(::webrtc::audio_network_adaptor::config::ChannelController* channel_controller) {
  clear_controller();
  if (channel_controller) {
    set_has_channel_controller();
    controller_.channel_controller_ = channel_controller;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audio_network_adaptor.config.Controller.channel_controller)
}

// optional .webrtc.audio_network_adaptor.config.DtxController dtx_controller = 24;
bool Controller::has_dtx_controller() const {
  return controller_case() == kDtxController;
}
void Controller::set_has_dtx_controller() {
  _oneof_case_[0] = kDtxController;
}
void Controller::clear_dtx_controller() {
  if (has_dtx_controller()) {
    delete controller_.dtx_controller_;
    clear_has_controller();
  }
}
 const ::webrtc::audio_network_adaptor::config::DtxController& Controller::dtx_controller() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.Controller.dtx_controller)
  return has_dtx_controller()
      ? *controller_.dtx_controller_
      : ::webrtc::audio_network_adaptor::config::DtxController::default_instance();
}
::webrtc::audio_network_adaptor::config::DtxController* Controller::mutable_dtx_controller() {
  if (!has_dtx_controller()) {
    clear_controller();
    set_has_dtx_controller();
    controller_.dtx_controller_ = new ::webrtc::audio_network_adaptor::config::DtxController;
  }
  // @@protoc_insertion_point(field_mutable:webrtc.audio_network_adaptor.config.Controller.dtx_controller)
  return controller_.dtx_controller_;
}
::webrtc::audio_network_adaptor::config::DtxController* Controller::release_dtx_controller() {
  // @@protoc_insertion_point(field_release:webrtc.audio_network_adaptor.config.Controller.dtx_controller)
  if (has_dtx_controller()) {
    clear_has_controller();
    ::webrtc::audio_network_adaptor::config::DtxController* temp = controller_.dtx_controller_;
    controller_.dtx_controller_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void Controller::set_allocated_dtx_controller(::webrtc::audio_network_adaptor::config::DtxController* dtx_controller) {
  clear_controller();
  if (dtx_controller) {
    set_has_dtx_controller();
    controller_.dtx_controller_ = dtx_controller;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audio_network_adaptor.config.Controller.dtx_controller)
}

// optional .webrtc.audio_network_adaptor.config.BitrateController bitrate_controller = 25;
bool Controller::has_bitrate_controller() const {
  return controller_case() == kBitrateController;
}
void Controller::set_has_bitrate_controller() {
  _oneof_case_[0] = kBitrateController;
}
void Controller::clear_bitrate_controller() {
  if (has_bitrate_controller()) {
    delete controller_.bitrate_controller_;
    clear_has_controller();
  }
}
 const ::webrtc::audio_network_adaptor::config::BitrateController& Controller::bitrate_controller() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.Controller.bitrate_controller)
  return has_bitrate_controller()
      ? *controller_.bitrate_controller_
      : ::webrtc::audio_network_adaptor::config::BitrateController::default_instance();
}
::webrtc::audio_network_adaptor::config::BitrateController* Controller::mutable_bitrate_controller() {
  if (!has_bitrate_controller()) {
    clear_controller();
    set_has_bitrate_controller();
    controller_.bitrate_controller_ = new ::webrtc::audio_network_adaptor::config::BitrateController;
  }
  // @@protoc_insertion_point(field_mutable:webrtc.audio_network_adaptor.config.Controller.bitrate_controller)
  return controller_.bitrate_controller_;
}
::webrtc::audio_network_adaptor::config::BitrateController* Controller::release_bitrate_controller() {
  // @@protoc_insertion_point(field_release:webrtc.audio_network_adaptor.config.Controller.bitrate_controller)
  if (has_bitrate_controller()) {
    clear_has_controller();
    ::webrtc::audio_network_adaptor::config::BitrateController* temp = controller_.bitrate_controller_;
    controller_.bitrate_controller_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void Controller::set_allocated_bitrate_controller(::webrtc::audio_network_adaptor::config::BitrateController* bitrate_controller) {
  clear_controller();
  if (bitrate_controller) {
    set_has_bitrate_controller();
    controller_.bitrate_controller_ = bitrate_controller;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audio_network_adaptor.config.Controller.bitrate_controller)
}

// optional .webrtc.audio_network_adaptor.config.FecControllerRplrBased fec_controller_rplr_based = 26;
bool Controller::has_fec_controller_rplr_based() const {
  return controller_case() == kFecControllerRplrBased;
}
void Controller::set_has_fec_controller_rplr_based() {
  _oneof_case_[0] = kFecControllerRplrBased;
}
void Controller::clear_fec_controller_rplr_based() {
  if (has_fec_controller_rplr_based()) {
    delete controller_.fec_controller_rplr_based_;
    clear_has_controller();
  }
}
 const ::webrtc::audio_network_adaptor::config::FecControllerRplrBased& Controller::fec_controller_rplr_based() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.Controller.fec_controller_rplr_based)
  return has_fec_controller_rplr_based()
      ? *controller_.fec_controller_rplr_based_
      : ::webrtc::audio_network_adaptor::config::FecControllerRplrBased::default_instance();
}
::webrtc::audio_network_adaptor::config::FecControllerRplrBased* Controller::mutable_fec_controller_rplr_based() {
  if (!has_fec_controller_rplr_based()) {
    clear_controller();
    set_has_fec_controller_rplr_based();
    controller_.fec_controller_rplr_based_ = new ::webrtc::audio_network_adaptor::config::FecControllerRplrBased;
  }
  // @@protoc_insertion_point(field_mutable:webrtc.audio_network_adaptor.config.Controller.fec_controller_rplr_based)
  return controller_.fec_controller_rplr_based_;
}
::webrtc::audio_network_adaptor::config::FecControllerRplrBased* Controller::release_fec_controller_rplr_based() {
  // @@protoc_insertion_point(field_release:webrtc.audio_network_adaptor.config.Controller.fec_controller_rplr_based)
  if (has_fec_controller_rplr_based()) {
    clear_has_controller();
    ::webrtc::audio_network_adaptor::config::FecControllerRplrBased* temp = controller_.fec_controller_rplr_based_;
    controller_.fec_controller_rplr_based_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void Controller::set_allocated_fec_controller_rplr_based(::webrtc::audio_network_adaptor::config::FecControllerRplrBased* fec_controller_rplr_based) {
  clear_controller();
  if (fec_controller_rplr_based) {
    set_has_fec_controller_rplr_based();
    controller_.fec_controller_rplr_based_ = fec_controller_rplr_based;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audio_network_adaptor.config.Controller.fec_controller_rplr_based)
}

bool Controller::has_controller() const {
  return controller_case() != CONTROLLER_NOT_SET;
}
void Controller::clear_has_controller() {
  _oneof_case_[0] = CONTROLLER_NOT_SET;
}
Controller::ControllerCase Controller::controller_case() const {
  return Controller::ControllerCase(_oneof_case_[0]);
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ControllerManager::kControllersFieldNumber;
const int ControllerManager::kMinReorderingTimeMsFieldNumber;
const int ControllerManager::kMinReorderingSquaredDistanceFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ControllerManager::ControllerManager()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_config_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.audio_network_adaptor.config.ControllerManager)
}
ControllerManager::ControllerManager(const ControllerManager& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      controllers_(from.controllers_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&min_reordering_time_ms_, &from.min_reordering_time_ms_,
    static_cast<size_t>(reinterpret_cast<char*>(&min_reordering_squared_distance_) -
    reinterpret_cast<char*>(&min_reordering_time_ms_)) + sizeof(min_reordering_squared_distance_));
  // @@protoc_insertion_point(copy_constructor:webrtc.audio_network_adaptor.config.ControllerManager)
}

void ControllerManager::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&min_reordering_time_ms_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&min_reordering_squared_distance_) -
      reinterpret_cast<char*>(&min_reordering_time_ms_)) + sizeof(min_reordering_squared_distance_));
}

ControllerManager::~ControllerManager() {
  // @@protoc_insertion_point(destructor:webrtc.audio_network_adaptor.config.ControllerManager)
  SharedDtor();
}

void ControllerManager::SharedDtor() {
}

void ControllerManager::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ControllerManager& ControllerManager::default_instance() {
  protobuf_config_2eproto::InitDefaults();
  return *internal_default_instance();
}

ControllerManager* ControllerManager::New(::google::protobuf::Arena* arena) const {
  ControllerManager* n = new ControllerManager;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ControllerManager::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audio_network_adaptor.config.ControllerManager)
  controllers_.Clear();
  if (_has_bits_[0 / 32] & 3u) {
    ::memset(&min_reordering_time_ms_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&min_reordering_squared_distance_) -
        reinterpret_cast<char*>(&min_reordering_time_ms_)) + sizeof(min_reordering_squared_distance_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ControllerManager::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:webrtc.audio_network_adaptor.config.ControllerManager)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .webrtc.audio_network_adaptor.config.Controller controllers = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_controllers()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 min_reordering_time_ms = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_min_reordering_time_ms();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &min_reordering_time_ms_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float min_reordering_squared_distance = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(29u)) {
          set_has_min_reordering_squared_distance();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &min_reordering_squared_distance_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.audio_network_adaptor.config.ControllerManager)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.audio_network_adaptor.config.ControllerManager)
  return false;
#undef DO_
}

void ControllerManager::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.audio_network_adaptor.config.ControllerManager)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .webrtc.audio_network_adaptor.config.Controller controllers = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->controllers_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, this->controllers(static_cast<int>(i)), output);
  }

  cached_has_bits = _has_bits_[0];
  // optional int32 min_reordering_time_ms = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->min_reordering_time_ms(), output);
  }

  // optional float min_reordering_squared_distance = 3;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->min_reordering_squared_distance(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:webrtc.audio_network_adaptor.config.ControllerManager)
}

size_t ControllerManager::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:webrtc.audio_network_adaptor.config.ControllerManager)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // repeated .webrtc.audio_network_adaptor.config.Controller controllers = 1;
  {
    unsigned int count = static_cast<unsigned int>(this->controllers_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->controllers(static_cast<int>(i)));
    }
  }

  if (_has_bits_[0 / 32] & 3u) {
    // optional int32 min_reordering_time_ms = 2;
    if (has_min_reordering_time_ms()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->min_reordering_time_ms());
    }

    // optional float min_reordering_squared_distance = 3;
    if (has_min_reordering_squared_distance()) {
      total_size += 1 + 4;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ControllerManager::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ControllerManager*>(&from));
}

void ControllerManager::MergeFrom(const ControllerManager& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audio_network_adaptor.config.ControllerManager)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  controllers_.MergeFrom(from.controllers_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      min_reordering_time_ms_ = from.min_reordering_time_ms_;
    }
    if (cached_has_bits & 0x00000002u) {
      min_reordering_squared_distance_ = from.min_reordering_squared_distance_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ControllerManager::CopyFrom(const ControllerManager& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:webrtc.audio_network_adaptor.config.ControllerManager)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ControllerManager::IsInitialized() const {
  return true;
}

void ControllerManager::Swap(ControllerManager* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ControllerManager::InternalSwap(ControllerManager* other) {
  controllers_.InternalSwap(&other->controllers_);
  std::swap(min_reordering_time_ms_, other->min_reordering_time_ms_);
  std::swap(min_reordering_squared_distance_, other->min_reordering_squared_distance_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string ControllerManager::GetTypeName() const {
  return "webrtc.audio_network_adaptor.config.ControllerManager";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// ControllerManager

// repeated .webrtc.audio_network_adaptor.config.Controller controllers = 1;
int ControllerManager::controllers_size() const {
  return controllers_.size();
}
void ControllerManager::clear_controllers() {
  controllers_.Clear();
}
const ::webrtc::audio_network_adaptor::config::Controller& ControllerManager::controllers(int index) const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.ControllerManager.controllers)
  return controllers_.Get(index);
}
::webrtc::audio_network_adaptor::config::Controller* ControllerManager::mutable_controllers(int index) {
  // @@protoc_insertion_point(field_mutable:webrtc.audio_network_adaptor.config.ControllerManager.controllers)
  return controllers_.Mutable(index);
}
::webrtc::audio_network_adaptor::config::Controller* ControllerManager::add_controllers() {
  // @@protoc_insertion_point(field_add:webrtc.audio_network_adaptor.config.ControllerManager.controllers)
  return controllers_.Add();
}
::google::protobuf::RepeatedPtrField< ::webrtc::audio_network_adaptor::config::Controller >*
ControllerManager::mutable_controllers() {
  // @@protoc_insertion_point(field_mutable_list:webrtc.audio_network_adaptor.config.ControllerManager.controllers)
  return &controllers_;
}
const ::google::protobuf::RepeatedPtrField< ::webrtc::audio_network_adaptor::config::Controller >&
ControllerManager::controllers() const {
  // @@protoc_insertion_point(field_list:webrtc.audio_network_adaptor.config.ControllerManager.controllers)
  return controllers_;
}

// optional int32 min_reordering_time_ms = 2;
bool ControllerManager::has_min_reordering_time_ms() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void ControllerManager::set_has_min_reordering_time_ms() {
  _has_bits_[0] |= 0x00000001u;
}
void ControllerManager::clear_has_min_reordering_time_ms() {
  _has_bits_[0] &= ~0x00000001u;
}
void ControllerManager::clear_min_reordering_time_ms() {
  min_reordering_time_ms_ = 0;
  clear_has_min_reordering_time_ms();
}
::google::protobuf::int32 ControllerManager::min_reordering_time_ms() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.ControllerManager.min_reordering_time_ms)
  return min_reordering_time_ms_;
}
void ControllerManager::set_min_reordering_time_ms(::google::protobuf::int32 value) {
  set_has_min_reordering_time_ms();
  min_reordering_time_ms_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.ControllerManager.min_reordering_time_ms)
}

// optional float min_reordering_squared_distance = 3;
bool ControllerManager::has_min_reordering_squared_distance() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void ControllerManager::set_has_min_reordering_squared_distance() {
  _has_bits_[0] |= 0x00000002u;
}
void ControllerManager::clear_has_min_reordering_squared_distance() {
  _has_bits_[0] &= ~0x00000002u;
}
void ControllerManager::clear_min_reordering_squared_distance() {
  min_reordering_squared_distance_ = 0;
  clear_has_min_reordering_squared_distance();
}
float ControllerManager::min_reordering_squared_distance() const {
  // @@protoc_insertion_point(field_get:webrtc.audio_network_adaptor.config.ControllerManager.min_reordering_squared_distance)
  return min_reordering_squared_distance_;
}
void ControllerManager::set_min_reordering_squared_distance(float value) {
  set_has_min_reordering_squared_distance();
  min_reordering_squared_distance_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audio_network_adaptor.config.ControllerManager.min_reordering_squared_distance)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// @@protoc_insertion_point(namespace_scope)

}  // namespace config
}  // namespace audio_network_adaptor
}  // namespace webrtc

// @@protoc_insertion_point(global_scope)
