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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "debug.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 audioproc {
class InitDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Init> {
} _Init_default_instance_;
class ReverseStreamDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<ReverseStream> {
} _ReverseStream_default_instance_;
class StreamDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Stream> {
} _Stream_default_instance_;
class ConfigDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Config> {
} _Config_default_instance_;
class EventDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Event> {
} _Event_default_instance_;

namespace protobuf_debug_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 },
};


void TableStruct::Shutdown() {
  _Init_default_instance_.Shutdown();
  _ReverseStream_default_instance_.Shutdown();
  _Stream_default_instance_.Shutdown();
  _Config_default_instance_.Shutdown();
  _Event_default_instance_.Shutdown();
}

void TableStruct::InitDefaultsImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::google::protobuf::internal::InitProtobufDefaults();
  _Init_default_instance_.DefaultConstruct();
  _ReverseStream_default_instance_.DefaultConstruct();
  _Stream_default_instance_.DefaultConstruct();
  _Config_default_instance_.DefaultConstruct();
  _Event_default_instance_.DefaultConstruct();
  _Event_default_instance_.get_mutable()->init_ = const_cast< ::webrtc::audioproc::Init*>(
      ::webrtc::audioproc::Init::internal_default_instance());
  _Event_default_instance_.get_mutable()->reverse_stream_ = const_cast< ::webrtc::audioproc::ReverseStream*>(
      ::webrtc::audioproc::ReverseStream::internal_default_instance());
  _Event_default_instance_.get_mutable()->stream_ = const_cast< ::webrtc::audioproc::Stream*>(
      ::webrtc::audioproc::Stream::internal_default_instance());
  _Event_default_instance_.get_mutable()->config_ = const_cast< ::webrtc::audioproc::Config*>(
      ::webrtc::audioproc::Config::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_debug_2eproto

bool Event_Type_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const Event_Type Event::INIT;
const Event_Type Event::REVERSE_STREAM;
const Event_Type Event::STREAM;
const Event_Type Event::CONFIG;
const Event_Type Event::UNKNOWN_EVENT;
const Event_Type Event::Type_MIN;
const Event_Type Event::Type_MAX;
const int Event::Type_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int Init::kSampleRateFieldNumber;
const int Init::kDeviceSampleRateFieldNumber;
const int Init::kNumInputChannelsFieldNumber;
const int Init::kNumOutputChannelsFieldNumber;
const int Init::kNumReverseChannelsFieldNumber;
const int Init::kReverseSampleRateFieldNumber;
const int Init::kOutputSampleRateFieldNumber;
const int Init::kReverseOutputSampleRateFieldNumber;
const int Init::kNumReverseOutputChannelsFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

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

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

Init::~Init() {
  // @@protoc_insertion_point(destructor:webrtc.audioproc.Init)
  SharedDtor();
}

void Init::SharedDtor() {
}

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

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

void Init::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audioproc.Init)
  if (_has_bits_[0 / 32] & 255u) {
    ::memset(&sample_rate_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&reverse_output_sample_rate_) -
        reinterpret_cast<char*>(&sample_rate_)) + sizeof(reverse_output_sample_rate_));
  }
  num_reverse_output_channels_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool Init::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.audioproc.Init)
  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 sample_rate = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_sample_rate();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &sample_rate_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 device_sample_rate = 2 [deprecated = true];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_device_sample_rate();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &device_sample_rate_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

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

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

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

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

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

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

      // optional int32 num_reverse_output_channels = 9;
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(72u)) {
          set_has_num_reverse_output_channels();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &num_reverse_output_channels_)));
        } 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.audioproc.Init)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.audioproc.Init)
  return false;
#undef DO_
}

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

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

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

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

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

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

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

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

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

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

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

size_t Init::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:webrtc.audioproc.Init)
  size_t total_size = 0;

  total_size += unknown_fields().size();

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

    // optional int32 device_sample_rate = 2 [deprecated = true];
    if (has_device_sample_rate()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->device_sample_rate());
    }

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

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

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

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

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

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

  }
  // optional int32 num_reverse_output_channels = 9;
  if (has_num_reverse_output_channels()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->num_reverse_output_channels());
  }

  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 Init::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const Init*>(&from));
}

void Init::MergeFrom(const Init& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audioproc.Init)
  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) {
      sample_rate_ = from.sample_rate_;
    }
    if (cached_has_bits & 0x00000002u) {
      device_sample_rate_ = from.device_sample_rate_;
    }
    if (cached_has_bits & 0x00000004u) {
      num_input_channels_ = from.num_input_channels_;
    }
    if (cached_has_bits & 0x00000008u) {
      num_output_channels_ = from.num_output_channels_;
    }
    if (cached_has_bits & 0x00000010u) {
      num_reverse_channels_ = from.num_reverse_channels_;
    }
    if (cached_has_bits & 0x00000020u) {
      reverse_sample_rate_ = from.reverse_sample_rate_;
    }
    if (cached_has_bits & 0x00000040u) {
      output_sample_rate_ = from.output_sample_rate_;
    }
    if (cached_has_bits & 0x00000080u) {
      reverse_output_sample_rate_ = from.reverse_output_sample_rate_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00000100u) {
    set_num_reverse_output_channels(from.num_reverse_output_channels());
  }
}

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

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

void Init::Swap(Init* other) {
  if (other == this) return;
  InternalSwap(other);
}
void Init::InternalSwap(Init* other) {
  std::swap(sample_rate_, other->sample_rate_);
  std::swap(device_sample_rate_, other->device_sample_rate_);
  std::swap(num_input_channels_, other->num_input_channels_);
  std::swap(num_output_channels_, other->num_output_channels_);
  std::swap(num_reverse_channels_, other->num_reverse_channels_);
  std::swap(reverse_sample_rate_, other->reverse_sample_rate_);
  std::swap(output_sample_rate_, other->output_sample_rate_);
  std::swap(reverse_output_sample_rate_, other->reverse_output_sample_rate_);
  std::swap(num_reverse_output_channels_, other->num_reverse_output_channels_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string Init::GetTypeName() const {
  return "webrtc.audioproc.Init";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// Init

// optional int32 sample_rate = 1;
bool Init::has_sample_rate() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void Init::set_has_sample_rate() {
  _has_bits_[0] |= 0x00000001u;
}
void Init::clear_has_sample_rate() {
  _has_bits_[0] &= ~0x00000001u;
}
void Init::clear_sample_rate() {
  sample_rate_ = 0;
  clear_has_sample_rate();
}
::google::protobuf::int32 Init::sample_rate() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Init.sample_rate)
  return sample_rate_;
}
void Init::set_sample_rate(::google::protobuf::int32 value) {
  set_has_sample_rate();
  sample_rate_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Init.sample_rate)
}

// optional int32 device_sample_rate = 2 [deprecated = true];
bool Init::has_device_sample_rate() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void Init::set_has_device_sample_rate() {
  _has_bits_[0] |= 0x00000002u;
}
void Init::clear_has_device_sample_rate() {
  _has_bits_[0] &= ~0x00000002u;
}
void Init::clear_device_sample_rate() {
  device_sample_rate_ = 0;
  clear_has_device_sample_rate();
}
::google::protobuf::int32 Init::device_sample_rate() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Init.device_sample_rate)
  return device_sample_rate_;
}
void Init::set_device_sample_rate(::google::protobuf::int32 value) {
  set_has_device_sample_rate();
  device_sample_rate_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Init.device_sample_rate)
}

// optional int32 num_input_channels = 3;
bool Init::has_num_input_channels() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void Init::set_has_num_input_channels() {
  _has_bits_[0] |= 0x00000004u;
}
void Init::clear_has_num_input_channels() {
  _has_bits_[0] &= ~0x00000004u;
}
void Init::clear_num_input_channels() {
  num_input_channels_ = 0;
  clear_has_num_input_channels();
}
::google::protobuf::int32 Init::num_input_channels() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Init.num_input_channels)
  return num_input_channels_;
}
void Init::set_num_input_channels(::google::protobuf::int32 value) {
  set_has_num_input_channels();
  num_input_channels_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Init.num_input_channels)
}

// optional int32 num_output_channels = 4;
bool Init::has_num_output_channels() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void Init::set_has_num_output_channels() {
  _has_bits_[0] |= 0x00000008u;
}
void Init::clear_has_num_output_channels() {
  _has_bits_[0] &= ~0x00000008u;
}
void Init::clear_num_output_channels() {
  num_output_channels_ = 0;
  clear_has_num_output_channels();
}
::google::protobuf::int32 Init::num_output_channels() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Init.num_output_channels)
  return num_output_channels_;
}
void Init::set_num_output_channels(::google::protobuf::int32 value) {
  set_has_num_output_channels();
  num_output_channels_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Init.num_output_channels)
}

// optional int32 num_reverse_channels = 5;
bool Init::has_num_reverse_channels() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void Init::set_has_num_reverse_channels() {
  _has_bits_[0] |= 0x00000010u;
}
void Init::clear_has_num_reverse_channels() {
  _has_bits_[0] &= ~0x00000010u;
}
void Init::clear_num_reverse_channels() {
  num_reverse_channels_ = 0;
  clear_has_num_reverse_channels();
}
::google::protobuf::int32 Init::num_reverse_channels() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Init.num_reverse_channels)
  return num_reverse_channels_;
}
void Init::set_num_reverse_channels(::google::protobuf::int32 value) {
  set_has_num_reverse_channels();
  num_reverse_channels_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Init.num_reverse_channels)
}

// optional int32 reverse_sample_rate = 6;
bool Init::has_reverse_sample_rate() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void Init::set_has_reverse_sample_rate() {
  _has_bits_[0] |= 0x00000020u;
}
void Init::clear_has_reverse_sample_rate() {
  _has_bits_[0] &= ~0x00000020u;
}
void Init::clear_reverse_sample_rate() {
  reverse_sample_rate_ = 0;
  clear_has_reverse_sample_rate();
}
::google::protobuf::int32 Init::reverse_sample_rate() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Init.reverse_sample_rate)
  return reverse_sample_rate_;
}
void Init::set_reverse_sample_rate(::google::protobuf::int32 value) {
  set_has_reverse_sample_rate();
  reverse_sample_rate_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Init.reverse_sample_rate)
}

// optional int32 output_sample_rate = 7;
bool Init::has_output_sample_rate() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void Init::set_has_output_sample_rate() {
  _has_bits_[0] |= 0x00000040u;
}
void Init::clear_has_output_sample_rate() {
  _has_bits_[0] &= ~0x00000040u;
}
void Init::clear_output_sample_rate() {
  output_sample_rate_ = 0;
  clear_has_output_sample_rate();
}
::google::protobuf::int32 Init::output_sample_rate() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Init.output_sample_rate)
  return output_sample_rate_;
}
void Init::set_output_sample_rate(::google::protobuf::int32 value) {
  set_has_output_sample_rate();
  output_sample_rate_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Init.output_sample_rate)
}

// optional int32 reverse_output_sample_rate = 8;
bool Init::has_reverse_output_sample_rate() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
void Init::set_has_reverse_output_sample_rate() {
  _has_bits_[0] |= 0x00000080u;
}
void Init::clear_has_reverse_output_sample_rate() {
  _has_bits_[0] &= ~0x00000080u;
}
void Init::clear_reverse_output_sample_rate() {
  reverse_output_sample_rate_ = 0;
  clear_has_reverse_output_sample_rate();
}
::google::protobuf::int32 Init::reverse_output_sample_rate() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Init.reverse_output_sample_rate)
  return reverse_output_sample_rate_;
}
void Init::set_reverse_output_sample_rate(::google::protobuf::int32 value) {
  set_has_reverse_output_sample_rate();
  reverse_output_sample_rate_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Init.reverse_output_sample_rate)
}

// optional int32 num_reverse_output_channels = 9;
bool Init::has_num_reverse_output_channels() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
void Init::set_has_num_reverse_output_channels() {
  _has_bits_[0] |= 0x00000100u;
}
void Init::clear_has_num_reverse_output_channels() {
  _has_bits_[0] &= ~0x00000100u;
}
void Init::clear_num_reverse_output_channels() {
  num_reverse_output_channels_ = 0;
  clear_has_num_reverse_output_channels();
}
::google::protobuf::int32 Init::num_reverse_output_channels() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Init.num_reverse_output_channels)
  return num_reverse_output_channels_;
}
void Init::set_num_reverse_output_channels(::google::protobuf::int32 value) {
  set_has_num_reverse_output_channels();
  num_reverse_output_channels_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Init.num_reverse_output_channels)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ReverseStream::kDataFieldNumber;
const int ReverseStream::kChannelFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ReverseStream::ReverseStream()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_debug_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.audioproc.ReverseStream)
}
ReverseStream::ReverseStream(const ReverseStream& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      channel_(from.channel_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_data()) {
    data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.data_);
  }
  // @@protoc_insertion_point(copy_constructor:webrtc.audioproc.ReverseStream)
}

void ReverseStream::SharedCtor() {
  _cached_size_ = 0;
  data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

ReverseStream::~ReverseStream() {
  // @@protoc_insertion_point(destructor:webrtc.audioproc.ReverseStream)
  SharedDtor();
}

void ReverseStream::SharedDtor() {
  data_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

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

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

void ReverseStream::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audioproc.ReverseStream)
  channel_.Clear();
  if (has_data()) {
    GOOGLE_DCHECK(!data_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*data_.UnsafeRawStringPointer())->clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ReverseStream::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.audioproc.ReverseStream)
  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 bytes data = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated bytes channel = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->add_channel()));
        } 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.audioproc.ReverseStream)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.audioproc.ReverseStream)
  return false;
#undef DO_
}

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

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

  // repeated bytes channel = 2;
  for (int i = 0, n = this->channel_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      2, this->channel(i), output);
  }

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

size_t ReverseStream::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:webrtc.audioproc.ReverseStream)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // repeated bytes channel = 2;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->channel_size());
  for (int i = 0, n = this->channel_size(); i < n; i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
      this->channel(i));
  }

  // optional bytes data = 1;
  if (has_data()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::BytesSize(
        this->data());
  }

  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 ReverseStream::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ReverseStream*>(&from));
}

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

  channel_.MergeFrom(from.channel_);
  if (from.has_data()) {
    set_has_data();
    data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.data_);
  }
}

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

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

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

::std::string ReverseStream::GetTypeName() const {
  return "webrtc.audioproc.ReverseStream";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// ReverseStream

// optional bytes data = 1;
bool ReverseStream::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void ReverseStream::set_has_data() {
  _has_bits_[0] |= 0x00000001u;
}
void ReverseStream::clear_has_data() {
  _has_bits_[0] &= ~0x00000001u;
}
void ReverseStream::clear_data() {
  data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_data();
}
const ::std::string& ReverseStream::data() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.ReverseStream.data)
  return data_.GetNoArena();
}
void ReverseStream::set_data(const ::std::string& value) {
  set_has_data();
  data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:webrtc.audioproc.ReverseStream.data)
}
#if LANG_CXX11
void ReverseStream::set_data(::std::string&& value) {
  set_has_data();
  data_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:webrtc.audioproc.ReverseStream.data)
}
#endif
void ReverseStream::set_data(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_data();
  data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:webrtc.audioproc.ReverseStream.data)
}
void ReverseStream::set_data(const void* value, size_t size) {
  set_has_data();
  data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:webrtc.audioproc.ReverseStream.data)
}
::std::string* ReverseStream::mutable_data() {
  set_has_data();
  // @@protoc_insertion_point(field_mutable:webrtc.audioproc.ReverseStream.data)
  return data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* ReverseStream::release_data() {
  // @@protoc_insertion_point(field_release:webrtc.audioproc.ReverseStream.data)
  clear_has_data();
  return data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void ReverseStream::set_allocated_data(::std::string* data) {
  if (data != NULL) {
    set_has_data();
  } else {
    clear_has_data();
  }
  data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), data);
  // @@protoc_insertion_point(field_set_allocated:webrtc.audioproc.ReverseStream.data)
}

// repeated bytes channel = 2;
int ReverseStream::channel_size() const {
  return channel_.size();
}
void ReverseStream::clear_channel() {
  channel_.Clear();
}
const ::std::string& ReverseStream::channel(int index) const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.ReverseStream.channel)
  return channel_.Get(index);
}
::std::string* ReverseStream::mutable_channel(int index) {
  // @@protoc_insertion_point(field_mutable:webrtc.audioproc.ReverseStream.channel)
  return channel_.Mutable(index);
}
void ReverseStream::set_channel(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:webrtc.audioproc.ReverseStream.channel)
  channel_.Mutable(index)->assign(value);
}
#if LANG_CXX11
void ReverseStream::set_channel(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:webrtc.audioproc.ReverseStream.channel)
  channel_.Mutable(index)->assign(std::move(value));
}
#endif
void ReverseStream::set_channel(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  channel_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:webrtc.audioproc.ReverseStream.channel)
}
void ReverseStream::set_channel(int index, const void* value, size_t size) {
  channel_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:webrtc.audioproc.ReverseStream.channel)
}
::std::string* ReverseStream::add_channel() {
  // @@protoc_insertion_point(field_add_mutable:webrtc.audioproc.ReverseStream.channel)
  return channel_.Add();
}
void ReverseStream::add_channel(const ::std::string& value) {
  channel_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:webrtc.audioproc.ReverseStream.channel)
}
#if LANG_CXX11
void ReverseStream::add_channel(::std::string&& value) {
  channel_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:webrtc.audioproc.ReverseStream.channel)
}
#endif
void ReverseStream::add_channel(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  channel_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:webrtc.audioproc.ReverseStream.channel)
}
void ReverseStream::add_channel(const void* value, size_t size) {
  channel_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:webrtc.audioproc.ReverseStream.channel)
}
const ::google::protobuf::RepeatedPtrField< ::std::string>&
ReverseStream::channel() const {
  // @@protoc_insertion_point(field_list:webrtc.audioproc.ReverseStream.channel)
  return channel_;
}
::google::protobuf::RepeatedPtrField< ::std::string>*
ReverseStream::mutable_channel() {
  // @@protoc_insertion_point(field_mutable_list:webrtc.audioproc.ReverseStream.channel)
  return &channel_;
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int Stream::kInputDataFieldNumber;
const int Stream::kOutputDataFieldNumber;
const int Stream::kDelayFieldNumber;
const int Stream::kDriftFieldNumber;
const int Stream::kLevelFieldNumber;
const int Stream::kKeypressFieldNumber;
const int Stream::kInputChannelFieldNumber;
const int Stream::kOutputChannelFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

Stream::Stream()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_debug_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.audioproc.Stream)
}
Stream::Stream(const Stream& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      input_channel_(from.input_channel_),
      output_channel_(from.output_channel_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  input_data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_input_data()) {
    input_data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.input_data_);
  }
  output_data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_output_data()) {
    output_data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.output_data_);
  }
  ::memcpy(&delay_, &from.delay_,
    static_cast<size_t>(reinterpret_cast<char*>(&keypress_) -
    reinterpret_cast<char*>(&delay_)) + sizeof(keypress_));
  // @@protoc_insertion_point(copy_constructor:webrtc.audioproc.Stream)
}

void Stream::SharedCtor() {
  _cached_size_ = 0;
  input_data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  output_data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&delay_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&keypress_) -
      reinterpret_cast<char*>(&delay_)) + sizeof(keypress_));
}

Stream::~Stream() {
  // @@protoc_insertion_point(destructor:webrtc.audioproc.Stream)
  SharedDtor();
}

void Stream::SharedDtor() {
  input_data_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  output_data_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

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

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

void Stream::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audioproc.Stream)
  input_channel_.Clear();
  output_channel_.Clear();
  if (_has_bits_[0 / 32] & 3u) {
    if (has_input_data()) {
      GOOGLE_DCHECK(!input_data_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*input_data_.UnsafeRawStringPointer())->clear();
    }
    if (has_output_data()) {
      GOOGLE_DCHECK(!output_data_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*output_data_.UnsafeRawStringPointer())->clear();
    }
  }
  if (_has_bits_[0 / 32] & 60u) {
    ::memset(&delay_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&keypress_) -
        reinterpret_cast<char*>(&delay_)) + sizeof(keypress_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool Stream::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.audioproc.Stream)
  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 bytes input_data = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_input_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes output_data = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_output_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

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

      // optional sint32 drift = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u)) {
          set_has_drift();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SINT32>(
                 input, &drift_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

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

      // optional bool keypress = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u)) {
          set_has_keypress();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &keypress_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated bytes input_channel = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(58u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->add_input_channel()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated bytes output_channel = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->add_output_channel()));
        } 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.audioproc.Stream)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.audioproc.Stream)
  return false;
#undef DO_
}

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

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

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

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

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

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

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

  // repeated bytes input_channel = 7;
  for (int i = 0, n = this->input_channel_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      7, this->input_channel(i), output);
  }

  // repeated bytes output_channel = 8;
  for (int i = 0, n = this->output_channel_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      8, this->output_channel(i), output);
  }

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

size_t Stream::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:webrtc.audioproc.Stream)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // repeated bytes input_channel = 7;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->input_channel_size());
  for (int i = 0, n = this->input_channel_size(); i < n; i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
      this->input_channel(i));
  }

  // repeated bytes output_channel = 8;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->output_channel_size());
  for (int i = 0, n = this->output_channel_size(); i < n; i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
      this->output_channel(i));
  }

  if (_has_bits_[0 / 32] & 63u) {
    // optional bytes input_data = 1;
    if (has_input_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->input_data());
    }

    // optional bytes output_data = 2;
    if (has_output_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->output_data());
    }

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

    // optional sint32 drift = 4;
    if (has_drift()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::SInt32Size(
          this->drift());
    }

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

    // optional bool keypress = 6;
    if (has_keypress()) {
      total_size += 1 + 1;
    }

  }
  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 Stream::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const Stream*>(&from));
}

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

  input_channel_.MergeFrom(from.input_channel_);
  output_channel_.MergeFrom(from.output_channel_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 63u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_input_data();
      input_data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.input_data_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_output_data();
      output_data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.output_data_);
    }
    if (cached_has_bits & 0x00000004u) {
      delay_ = from.delay_;
    }
    if (cached_has_bits & 0x00000008u) {
      drift_ = from.drift_;
    }
    if (cached_has_bits & 0x00000010u) {
      level_ = from.level_;
    }
    if (cached_has_bits & 0x00000020u) {
      keypress_ = from.keypress_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void Stream::Swap(Stream* other) {
  if (other == this) return;
  InternalSwap(other);
}
void Stream::InternalSwap(Stream* other) {
  input_channel_.InternalSwap(&other->input_channel_);
  output_channel_.InternalSwap(&other->output_channel_);
  input_data_.Swap(&other->input_data_);
  output_data_.Swap(&other->output_data_);
  std::swap(delay_, other->delay_);
  std::swap(drift_, other->drift_);
  std::swap(level_, other->level_);
  std::swap(keypress_, other->keypress_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string Stream::GetTypeName() const {
  return "webrtc.audioproc.Stream";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// Stream

// optional bytes input_data = 1;
bool Stream::has_input_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void Stream::set_has_input_data() {
  _has_bits_[0] |= 0x00000001u;
}
void Stream::clear_has_input_data() {
  _has_bits_[0] &= ~0x00000001u;
}
void Stream::clear_input_data() {
  input_data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_input_data();
}
const ::std::string& Stream::input_data() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.input_data)
  return input_data_.GetNoArena();
}
void Stream::set_input_data(const ::std::string& value) {
  set_has_input_data();
  input_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.input_data)
}
#if LANG_CXX11
void Stream::set_input_data(::std::string&& value) {
  set_has_input_data();
  input_data_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:webrtc.audioproc.Stream.input_data)
}
#endif
void Stream::set_input_data(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_input_data();
  input_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:webrtc.audioproc.Stream.input_data)
}
void Stream::set_input_data(const void* value, size_t size) {
  set_has_input_data();
  input_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:webrtc.audioproc.Stream.input_data)
}
::std::string* Stream::mutable_input_data() {
  set_has_input_data();
  // @@protoc_insertion_point(field_mutable:webrtc.audioproc.Stream.input_data)
  return input_data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* Stream::release_input_data() {
  // @@protoc_insertion_point(field_release:webrtc.audioproc.Stream.input_data)
  clear_has_input_data();
  return input_data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void Stream::set_allocated_input_data(::std::string* input_data) {
  if (input_data != NULL) {
    set_has_input_data();
  } else {
    clear_has_input_data();
  }
  input_data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), input_data);
  // @@protoc_insertion_point(field_set_allocated:webrtc.audioproc.Stream.input_data)
}

// optional bytes output_data = 2;
bool Stream::has_output_data() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void Stream::set_has_output_data() {
  _has_bits_[0] |= 0x00000002u;
}
void Stream::clear_has_output_data() {
  _has_bits_[0] &= ~0x00000002u;
}
void Stream::clear_output_data() {
  output_data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_output_data();
}
const ::std::string& Stream::output_data() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.output_data)
  return output_data_.GetNoArena();
}
void Stream::set_output_data(const ::std::string& value) {
  set_has_output_data();
  output_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.output_data)
}
#if LANG_CXX11
void Stream::set_output_data(::std::string&& value) {
  set_has_output_data();
  output_data_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:webrtc.audioproc.Stream.output_data)
}
#endif
void Stream::set_output_data(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_output_data();
  output_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:webrtc.audioproc.Stream.output_data)
}
void Stream::set_output_data(const void* value, size_t size) {
  set_has_output_data();
  output_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:webrtc.audioproc.Stream.output_data)
}
::std::string* Stream::mutable_output_data() {
  set_has_output_data();
  // @@protoc_insertion_point(field_mutable:webrtc.audioproc.Stream.output_data)
  return output_data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* Stream::release_output_data() {
  // @@protoc_insertion_point(field_release:webrtc.audioproc.Stream.output_data)
  clear_has_output_data();
  return output_data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void Stream::set_allocated_output_data(::std::string* output_data) {
  if (output_data != NULL) {
    set_has_output_data();
  } else {
    clear_has_output_data();
  }
  output_data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), output_data);
  // @@protoc_insertion_point(field_set_allocated:webrtc.audioproc.Stream.output_data)
}

// optional int32 delay = 3;
bool Stream::has_delay() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void Stream::set_has_delay() {
  _has_bits_[0] |= 0x00000004u;
}
void Stream::clear_has_delay() {
  _has_bits_[0] &= ~0x00000004u;
}
void Stream::clear_delay() {
  delay_ = 0;
  clear_has_delay();
}
::google::protobuf::int32 Stream::delay() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.delay)
  return delay_;
}
void Stream::set_delay(::google::protobuf::int32 value) {
  set_has_delay();
  delay_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.delay)
}

// optional sint32 drift = 4;
bool Stream::has_drift() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void Stream::set_has_drift() {
  _has_bits_[0] |= 0x00000008u;
}
void Stream::clear_has_drift() {
  _has_bits_[0] &= ~0x00000008u;
}
void Stream::clear_drift() {
  drift_ = 0;
  clear_has_drift();
}
::google::protobuf::int32 Stream::drift() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.drift)
  return drift_;
}
void Stream::set_drift(::google::protobuf::int32 value) {
  set_has_drift();
  drift_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.drift)
}

// optional int32 level = 5;
bool Stream::has_level() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void Stream::set_has_level() {
  _has_bits_[0] |= 0x00000010u;
}
void Stream::clear_has_level() {
  _has_bits_[0] &= ~0x00000010u;
}
void Stream::clear_level() {
  level_ = 0;
  clear_has_level();
}
::google::protobuf::int32 Stream::level() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.level)
  return level_;
}
void Stream::set_level(::google::protobuf::int32 value) {
  set_has_level();
  level_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.level)
}

// optional bool keypress = 6;
bool Stream::has_keypress() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void Stream::set_has_keypress() {
  _has_bits_[0] |= 0x00000020u;
}
void Stream::clear_has_keypress() {
  _has_bits_[0] &= ~0x00000020u;
}
void Stream::clear_keypress() {
  keypress_ = false;
  clear_has_keypress();
}
bool Stream::keypress() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.keypress)
  return keypress_;
}
void Stream::set_keypress(bool value) {
  set_has_keypress();
  keypress_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.keypress)
}

// repeated bytes input_channel = 7;
int Stream::input_channel_size() const {
  return input_channel_.size();
}
void Stream::clear_input_channel() {
  input_channel_.Clear();
}
const ::std::string& Stream::input_channel(int index) const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.input_channel)
  return input_channel_.Get(index);
}
::std::string* Stream::mutable_input_channel(int index) {
  // @@protoc_insertion_point(field_mutable:webrtc.audioproc.Stream.input_channel)
  return input_channel_.Mutable(index);
}
void Stream::set_input_channel(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.input_channel)
  input_channel_.Mutable(index)->assign(value);
}
#if LANG_CXX11
void Stream::set_input_channel(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.input_channel)
  input_channel_.Mutable(index)->assign(std::move(value));
}
#endif
void Stream::set_input_channel(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  input_channel_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:webrtc.audioproc.Stream.input_channel)
}
void Stream::set_input_channel(int index, const void* value, size_t size) {
  input_channel_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:webrtc.audioproc.Stream.input_channel)
}
::std::string* Stream::add_input_channel() {
  // @@protoc_insertion_point(field_add_mutable:webrtc.audioproc.Stream.input_channel)
  return input_channel_.Add();
}
void Stream::add_input_channel(const ::std::string& value) {
  input_channel_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:webrtc.audioproc.Stream.input_channel)
}
#if LANG_CXX11
void Stream::add_input_channel(::std::string&& value) {
  input_channel_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:webrtc.audioproc.Stream.input_channel)
}
#endif
void Stream::add_input_channel(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  input_channel_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:webrtc.audioproc.Stream.input_channel)
}
void Stream::add_input_channel(const void* value, size_t size) {
  input_channel_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:webrtc.audioproc.Stream.input_channel)
}
const ::google::protobuf::RepeatedPtrField< ::std::string>&
Stream::input_channel() const {
  // @@protoc_insertion_point(field_list:webrtc.audioproc.Stream.input_channel)
  return input_channel_;
}
::google::protobuf::RepeatedPtrField< ::std::string>*
Stream::mutable_input_channel() {
  // @@protoc_insertion_point(field_mutable_list:webrtc.audioproc.Stream.input_channel)
  return &input_channel_;
}

// repeated bytes output_channel = 8;
int Stream::output_channel_size() const {
  return output_channel_.size();
}
void Stream::clear_output_channel() {
  output_channel_.Clear();
}
const ::std::string& Stream::output_channel(int index) const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.output_channel)
  return output_channel_.Get(index);
}
::std::string* Stream::mutable_output_channel(int index) {
  // @@protoc_insertion_point(field_mutable:webrtc.audioproc.Stream.output_channel)
  return output_channel_.Mutable(index);
}
void Stream::set_output_channel(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.output_channel)
  output_channel_.Mutable(index)->assign(value);
}
#if LANG_CXX11
void Stream::set_output_channel(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.output_channel)
  output_channel_.Mutable(index)->assign(std::move(value));
}
#endif
void Stream::set_output_channel(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  output_channel_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:webrtc.audioproc.Stream.output_channel)
}
void Stream::set_output_channel(int index, const void* value, size_t size) {
  output_channel_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:webrtc.audioproc.Stream.output_channel)
}
::std::string* Stream::add_output_channel() {
  // @@protoc_insertion_point(field_add_mutable:webrtc.audioproc.Stream.output_channel)
  return output_channel_.Add();
}
void Stream::add_output_channel(const ::std::string& value) {
  output_channel_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:webrtc.audioproc.Stream.output_channel)
}
#if LANG_CXX11
void Stream::add_output_channel(::std::string&& value) {
  output_channel_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:webrtc.audioproc.Stream.output_channel)
}
#endif
void Stream::add_output_channel(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  output_channel_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:webrtc.audioproc.Stream.output_channel)
}
void Stream::add_output_channel(const void* value, size_t size) {
  output_channel_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:webrtc.audioproc.Stream.output_channel)
}
const ::google::protobuf::RepeatedPtrField< ::std::string>&
Stream::output_channel() const {
  // @@protoc_insertion_point(field_list:webrtc.audioproc.Stream.output_channel)
  return output_channel_;
}
::google::protobuf::RepeatedPtrField< ::std::string>*
Stream::mutable_output_channel() {
  // @@protoc_insertion_point(field_mutable_list:webrtc.audioproc.Stream.output_channel)
  return &output_channel_;
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int Config::kAecEnabledFieldNumber;
const int Config::kAecDelayAgnosticEnabledFieldNumber;
const int Config::kAecDriftCompensationEnabledFieldNumber;
const int Config::kAecExtendedFilterEnabledFieldNumber;
const int Config::kAecSuppressionLevelFieldNumber;
const int Config::kAecmEnabledFieldNumber;
const int Config::kAecmComfortNoiseEnabledFieldNumber;
const int Config::kAecmRoutingModeFieldNumber;
const int Config::kAgcEnabledFieldNumber;
const int Config::kAgcModeFieldNumber;
const int Config::kAgcLimiterEnabledFieldNumber;
const int Config::kNoiseRobustAgcEnabledFieldNumber;
const int Config::kHpfEnabledFieldNumber;
const int Config::kNsEnabledFieldNumber;
const int Config::kNsLevelFieldNumber;
const int Config::kTransientSuppressionEnabledFieldNumber;
const int Config::kExperimentsDescriptionFieldNumber;
const int Config::kIntelligibilityEnhancerEnabledFieldNumber;
const int Config::kPreAmplifierEnabledFieldNumber;
const int Config::kPreAmplifierFixedGainFactorFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

Config::Config()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_debug_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.audioproc.Config)
}
Config::Config(const Config& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  experiments_description_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_experiments_description()) {
    experiments_description_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.experiments_description_);
  }
  ::memcpy(&aec_enabled_, &from.aec_enabled_,
    static_cast<size_t>(reinterpret_cast<char*>(&pre_amplifier_fixed_gain_factor_) -
    reinterpret_cast<char*>(&aec_enabled_)) + sizeof(pre_amplifier_fixed_gain_factor_));
  // @@protoc_insertion_point(copy_constructor:webrtc.audioproc.Config)
}

void Config::SharedCtor() {
  _cached_size_ = 0;
  experiments_description_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&aec_enabled_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&pre_amplifier_fixed_gain_factor_) -
      reinterpret_cast<char*>(&aec_enabled_)) + sizeof(pre_amplifier_fixed_gain_factor_));
}

Config::~Config() {
  // @@protoc_insertion_point(destructor:webrtc.audioproc.Config)
  SharedDtor();
}

void Config::SharedDtor() {
  experiments_description_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

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

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

void Config::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audioproc.Config)
  if (has_experiments_description()) {
    GOOGLE_DCHECK(!experiments_description_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*experiments_description_.UnsafeRawStringPointer())->clear();
  }
  if (_has_bits_[0 / 32] & 254u) {
    ::memset(&aec_enabled_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&aecm_enabled_) -
        reinterpret_cast<char*>(&aec_enabled_)) + sizeof(aecm_enabled_));
  }
  if (_has_bits_[8 / 32] & 65280u) {
    ::memset(&aecm_comfort_noise_enabled_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&transient_suppression_enabled_) -
        reinterpret_cast<char*>(&aecm_comfort_noise_enabled_)) + sizeof(transient_suppression_enabled_));
  }
  if (_has_bits_[16 / 32] & 983040u) {
    ::memset(&ns_level_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&pre_amplifier_fixed_gain_factor_) -
        reinterpret_cast<char*>(&ns_level_)) + sizeof(pre_amplifier_fixed_gain_factor_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool Config::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.audioproc.Config)
  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 bool aec_enabled = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_aec_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &aec_enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool aec_delay_agnostic_enabled = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_aec_delay_agnostic_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &aec_delay_agnostic_enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool aec_drift_compensation_enabled = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_aec_drift_compensation_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &aec_drift_compensation_enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool aec_extended_filter_enabled = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u)) {
          set_has_aec_extended_filter_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &aec_extended_filter_enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

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

      // optional bool aecm_enabled = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u)) {
          set_has_aecm_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &aecm_enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool aecm_comfort_noise_enabled = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(56u)) {
          set_has_aecm_comfort_noise_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &aecm_comfort_noise_enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

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

      // optional bool agc_enabled = 9;
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(72u)) {
          set_has_agc_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &agc_enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 agc_mode = 10;
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(80u)) {
          set_has_agc_mode();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &agc_mode_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool agc_limiter_enabled = 11;
      case 11: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(88u)) {
          set_has_agc_limiter_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &agc_limiter_enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool noise_robust_agc_enabled = 12;
      case 12: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(96u)) {
          set_has_noise_robust_agc_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &noise_robust_agc_enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool hpf_enabled = 13;
      case 13: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(104u)) {
          set_has_hpf_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &hpf_enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool ns_enabled = 14;
      case 14: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(112u)) {
          set_has_ns_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &ns_enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 ns_level = 15;
      case 15: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(120u)) {
          set_has_ns_level();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &ns_level_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool transient_suppression_enabled = 16;
      case 16: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(128u)) {
          set_has_transient_suppression_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &transient_suppression_enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string experiments_description = 17;
      case 17: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(138u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_experiments_description()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool intelligibility_enhancer_enabled = 18;
      case 18: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(144u)) {
          set_has_intelligibility_enhancer_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &intelligibility_enhancer_enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool pre_amplifier_enabled = 19;
      case 19: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(152u)) {
          set_has_pre_amplifier_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &pre_amplifier_enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float pre_amplifier_fixed_gain_factor = 20;
      case 20: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(165u)) {
          set_has_pre_amplifier_fixed_gain_factor();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &pre_amplifier_fixed_gain_factor_)));
        } 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.audioproc.Config)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.audioproc.Config)
  return false;
#undef DO_
}

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

  cached_has_bits = _has_bits_[0];
  // optional bool aec_enabled = 1;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->aec_enabled(), output);
  }

  // optional bool aec_delay_agnostic_enabled = 2;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->aec_delay_agnostic_enabled(), output);
  }

  // optional bool aec_drift_compensation_enabled = 3;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->aec_drift_compensation_enabled(), output);
  }

  // optional bool aec_extended_filter_enabled = 4;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->aec_extended_filter_enabled(), output);
  }

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

  // optional bool aecm_enabled = 6;
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->aecm_enabled(), output);
  }

  // optional bool aecm_comfort_noise_enabled = 7;
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->aecm_comfort_noise_enabled(), output);
  }

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

  // optional bool agc_enabled = 9;
  if (cached_has_bits & 0x00000200u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->agc_enabled(), output);
  }

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

  // optional bool agc_limiter_enabled = 11;
  if (cached_has_bits & 0x00000400u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(11, this->agc_limiter_enabled(), output);
  }

  // optional bool noise_robust_agc_enabled = 12;
  if (cached_has_bits & 0x00001000u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(12, this->noise_robust_agc_enabled(), output);
  }

  // optional bool hpf_enabled = 13;
  if (cached_has_bits & 0x00002000u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(13, this->hpf_enabled(), output);
  }

  // optional bool ns_enabled = 14;
  if (cached_has_bits & 0x00004000u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(14, this->ns_enabled(), output);
  }

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

  // optional bool transient_suppression_enabled = 16;
  if (cached_has_bits & 0x00008000u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(16, this->transient_suppression_enabled(), output);
  }

  // optional string experiments_description = 17;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      17, this->experiments_description(), output);
  }

  // optional bool intelligibility_enhancer_enabled = 18;
  if (cached_has_bits & 0x00020000u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(18, this->intelligibility_enhancer_enabled(), output);
  }

  // optional bool pre_amplifier_enabled = 19;
  if (cached_has_bits & 0x00040000u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(19, this->pre_amplifier_enabled(), output);
  }

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

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

size_t Config::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:webrtc.audioproc.Config)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 255u) {
    // optional string experiments_description = 17;
    if (has_experiments_description()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->experiments_description());
    }

    // optional bool aec_enabled = 1;
    if (has_aec_enabled()) {
      total_size += 1 + 1;
    }

    // optional bool aec_delay_agnostic_enabled = 2;
    if (has_aec_delay_agnostic_enabled()) {
      total_size += 1 + 1;
    }

    // optional bool aec_drift_compensation_enabled = 3;
    if (has_aec_drift_compensation_enabled()) {
      total_size += 1 + 1;
    }

    // optional bool aec_extended_filter_enabled = 4;
    if (has_aec_extended_filter_enabled()) {
      total_size += 1 + 1;
    }

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

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

    // optional bool aecm_enabled = 6;
    if (has_aecm_enabled()) {
      total_size += 1 + 1;
    }

  }
  if (_has_bits_[8 / 32] & 65280u) {
    // optional bool aecm_comfort_noise_enabled = 7;
    if (has_aecm_comfort_noise_enabled()) {
      total_size += 1 + 1;
    }

    // optional bool agc_enabled = 9;
    if (has_agc_enabled()) {
      total_size += 1 + 1;
    }

    // optional bool agc_limiter_enabled = 11;
    if (has_agc_limiter_enabled()) {
      total_size += 1 + 1;
    }

    // optional int32 agc_mode = 10;
    if (has_agc_mode()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->agc_mode());
    }

    // optional bool noise_robust_agc_enabled = 12;
    if (has_noise_robust_agc_enabled()) {
      total_size += 1 + 1;
    }

    // optional bool hpf_enabled = 13;
    if (has_hpf_enabled()) {
      total_size += 1 + 1;
    }

    // optional bool ns_enabled = 14;
    if (has_ns_enabled()) {
      total_size += 1 + 1;
    }

    // optional bool transient_suppression_enabled = 16;
    if (has_transient_suppression_enabled()) {
      total_size += 2 + 1;
    }

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

    // optional bool intelligibility_enhancer_enabled = 18;
    if (has_intelligibility_enhancer_enabled()) {
      total_size += 2 + 1;
    }

    // optional bool pre_amplifier_enabled = 19;
    if (has_pre_amplifier_enabled()) {
      total_size += 2 + 1;
    }

    // optional float pre_amplifier_fixed_gain_factor = 20;
    if (has_pre_amplifier_fixed_gain_factor()) {
      total_size += 2 + 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 Config::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const Config*>(&from));
}

void Config::MergeFrom(const Config& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audioproc.Config)
  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) {
      set_has_experiments_description();
      experiments_description_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.experiments_description_);
    }
    if (cached_has_bits & 0x00000002u) {
      aec_enabled_ = from.aec_enabled_;
    }
    if (cached_has_bits & 0x00000004u) {
      aec_delay_agnostic_enabled_ = from.aec_delay_agnostic_enabled_;
    }
    if (cached_has_bits & 0x00000008u) {
      aec_drift_compensation_enabled_ = from.aec_drift_compensation_enabled_;
    }
    if (cached_has_bits & 0x00000010u) {
      aec_extended_filter_enabled_ = from.aec_extended_filter_enabled_;
    }
    if (cached_has_bits & 0x00000020u) {
      aec_suppression_level_ = from.aec_suppression_level_;
    }
    if (cached_has_bits & 0x00000040u) {
      aecm_routing_mode_ = from.aecm_routing_mode_;
    }
    if (cached_has_bits & 0x00000080u) {
      aecm_enabled_ = from.aecm_enabled_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 65280u) {
    if (cached_has_bits & 0x00000100u) {
      aecm_comfort_noise_enabled_ = from.aecm_comfort_noise_enabled_;
    }
    if (cached_has_bits & 0x00000200u) {
      agc_enabled_ = from.agc_enabled_;
    }
    if (cached_has_bits & 0x00000400u) {
      agc_limiter_enabled_ = from.agc_limiter_enabled_;
    }
    if (cached_has_bits & 0x00000800u) {
      agc_mode_ = from.agc_mode_;
    }
    if (cached_has_bits & 0x00001000u) {
      noise_robust_agc_enabled_ = from.noise_robust_agc_enabled_;
    }
    if (cached_has_bits & 0x00002000u) {
      hpf_enabled_ = from.hpf_enabled_;
    }
    if (cached_has_bits & 0x00004000u) {
      ns_enabled_ = from.ns_enabled_;
    }
    if (cached_has_bits & 0x00008000u) {
      transient_suppression_enabled_ = from.transient_suppression_enabled_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 983040u) {
    if (cached_has_bits & 0x00010000u) {
      ns_level_ = from.ns_level_;
    }
    if (cached_has_bits & 0x00020000u) {
      intelligibility_enhancer_enabled_ = from.intelligibility_enhancer_enabled_;
    }
    if (cached_has_bits & 0x00040000u) {
      pre_amplifier_enabled_ = from.pre_amplifier_enabled_;
    }
    if (cached_has_bits & 0x00080000u) {
      pre_amplifier_fixed_gain_factor_ = from.pre_amplifier_fixed_gain_factor_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void Config::Swap(Config* other) {
  if (other == this) return;
  InternalSwap(other);
}
void Config::InternalSwap(Config* other) {
  experiments_description_.Swap(&other->experiments_description_);
  std::swap(aec_enabled_, other->aec_enabled_);
  std::swap(aec_delay_agnostic_enabled_, other->aec_delay_agnostic_enabled_);
  std::swap(aec_drift_compensation_enabled_, other->aec_drift_compensation_enabled_);
  std::swap(aec_extended_filter_enabled_, other->aec_extended_filter_enabled_);
  std::swap(aec_suppression_level_, other->aec_suppression_level_);
  std::swap(aecm_routing_mode_, other->aecm_routing_mode_);
  std::swap(aecm_enabled_, other->aecm_enabled_);
  std::swap(aecm_comfort_noise_enabled_, other->aecm_comfort_noise_enabled_);
  std::swap(agc_enabled_, other->agc_enabled_);
  std::swap(agc_limiter_enabled_, other->agc_limiter_enabled_);
  std::swap(agc_mode_, other->agc_mode_);
  std::swap(noise_robust_agc_enabled_, other->noise_robust_agc_enabled_);
  std::swap(hpf_enabled_, other->hpf_enabled_);
  std::swap(ns_enabled_, other->ns_enabled_);
  std::swap(transient_suppression_enabled_, other->transient_suppression_enabled_);
  std::swap(ns_level_, other->ns_level_);
  std::swap(intelligibility_enhancer_enabled_, other->intelligibility_enhancer_enabled_);
  std::swap(pre_amplifier_enabled_, other->pre_amplifier_enabled_);
  std::swap(pre_amplifier_fixed_gain_factor_, other->pre_amplifier_fixed_gain_factor_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string Config::GetTypeName() const {
  return "webrtc.audioproc.Config";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// Config

// optional bool aec_enabled = 1;
bool Config::has_aec_enabled() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void Config::set_has_aec_enabled() {
  _has_bits_[0] |= 0x00000002u;
}
void Config::clear_has_aec_enabled() {
  _has_bits_[0] &= ~0x00000002u;
}
void Config::clear_aec_enabled() {
  aec_enabled_ = false;
  clear_has_aec_enabled();
}
bool Config::aec_enabled() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.aec_enabled)
  return aec_enabled_;
}
void Config::set_aec_enabled(bool value) {
  set_has_aec_enabled();
  aec_enabled_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.aec_enabled)
}

// optional bool aec_delay_agnostic_enabled = 2;
bool Config::has_aec_delay_agnostic_enabled() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void Config::set_has_aec_delay_agnostic_enabled() {
  _has_bits_[0] |= 0x00000004u;
}
void Config::clear_has_aec_delay_agnostic_enabled() {
  _has_bits_[0] &= ~0x00000004u;
}
void Config::clear_aec_delay_agnostic_enabled() {
  aec_delay_agnostic_enabled_ = false;
  clear_has_aec_delay_agnostic_enabled();
}
bool Config::aec_delay_agnostic_enabled() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.aec_delay_agnostic_enabled)
  return aec_delay_agnostic_enabled_;
}
void Config::set_aec_delay_agnostic_enabled(bool value) {
  set_has_aec_delay_agnostic_enabled();
  aec_delay_agnostic_enabled_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.aec_delay_agnostic_enabled)
}

// optional bool aec_drift_compensation_enabled = 3;
bool Config::has_aec_drift_compensation_enabled() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void Config::set_has_aec_drift_compensation_enabled() {
  _has_bits_[0] |= 0x00000008u;
}
void Config::clear_has_aec_drift_compensation_enabled() {
  _has_bits_[0] &= ~0x00000008u;
}
void Config::clear_aec_drift_compensation_enabled() {
  aec_drift_compensation_enabled_ = false;
  clear_has_aec_drift_compensation_enabled();
}
bool Config::aec_drift_compensation_enabled() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.aec_drift_compensation_enabled)
  return aec_drift_compensation_enabled_;
}
void Config::set_aec_drift_compensation_enabled(bool value) {
  set_has_aec_drift_compensation_enabled();
  aec_drift_compensation_enabled_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.aec_drift_compensation_enabled)
}

// optional bool aec_extended_filter_enabled = 4;
bool Config::has_aec_extended_filter_enabled() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void Config::set_has_aec_extended_filter_enabled() {
  _has_bits_[0] |= 0x00000010u;
}
void Config::clear_has_aec_extended_filter_enabled() {
  _has_bits_[0] &= ~0x00000010u;
}
void Config::clear_aec_extended_filter_enabled() {
  aec_extended_filter_enabled_ = false;
  clear_has_aec_extended_filter_enabled();
}
bool Config::aec_extended_filter_enabled() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.aec_extended_filter_enabled)
  return aec_extended_filter_enabled_;
}
void Config::set_aec_extended_filter_enabled(bool value) {
  set_has_aec_extended_filter_enabled();
  aec_extended_filter_enabled_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.aec_extended_filter_enabled)
}

// optional int32 aec_suppression_level = 5;
bool Config::has_aec_suppression_level() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void Config::set_has_aec_suppression_level() {
  _has_bits_[0] |= 0x00000020u;
}
void Config::clear_has_aec_suppression_level() {
  _has_bits_[0] &= ~0x00000020u;
}
void Config::clear_aec_suppression_level() {
  aec_suppression_level_ = 0;
  clear_has_aec_suppression_level();
}
::google::protobuf::int32 Config::aec_suppression_level() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.aec_suppression_level)
  return aec_suppression_level_;
}
void Config::set_aec_suppression_level(::google::protobuf::int32 value) {
  set_has_aec_suppression_level();
  aec_suppression_level_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.aec_suppression_level)
}

// optional bool aecm_enabled = 6;
bool Config::has_aecm_enabled() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
void Config::set_has_aecm_enabled() {
  _has_bits_[0] |= 0x00000080u;
}
void Config::clear_has_aecm_enabled() {
  _has_bits_[0] &= ~0x00000080u;
}
void Config::clear_aecm_enabled() {
  aecm_enabled_ = false;
  clear_has_aecm_enabled();
}
bool Config::aecm_enabled() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.aecm_enabled)
  return aecm_enabled_;
}
void Config::set_aecm_enabled(bool value) {
  set_has_aecm_enabled();
  aecm_enabled_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.aecm_enabled)
}

// optional bool aecm_comfort_noise_enabled = 7;
bool Config::has_aecm_comfort_noise_enabled() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
void Config::set_has_aecm_comfort_noise_enabled() {
  _has_bits_[0] |= 0x00000100u;
}
void Config::clear_has_aecm_comfort_noise_enabled() {
  _has_bits_[0] &= ~0x00000100u;
}
void Config::clear_aecm_comfort_noise_enabled() {
  aecm_comfort_noise_enabled_ = false;
  clear_has_aecm_comfort_noise_enabled();
}
bool Config::aecm_comfort_noise_enabled() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.aecm_comfort_noise_enabled)
  return aecm_comfort_noise_enabled_;
}
void Config::set_aecm_comfort_noise_enabled(bool value) {
  set_has_aecm_comfort_noise_enabled();
  aecm_comfort_noise_enabled_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.aecm_comfort_noise_enabled)
}

// optional int32 aecm_routing_mode = 8;
bool Config::has_aecm_routing_mode() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void Config::set_has_aecm_routing_mode() {
  _has_bits_[0] |= 0x00000040u;
}
void Config::clear_has_aecm_routing_mode() {
  _has_bits_[0] &= ~0x00000040u;
}
void Config::clear_aecm_routing_mode() {
  aecm_routing_mode_ = 0;
  clear_has_aecm_routing_mode();
}
::google::protobuf::int32 Config::aecm_routing_mode() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.aecm_routing_mode)
  return aecm_routing_mode_;
}
void Config::set_aecm_routing_mode(::google::protobuf::int32 value) {
  set_has_aecm_routing_mode();
  aecm_routing_mode_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.aecm_routing_mode)
}

// optional bool agc_enabled = 9;
bool Config::has_agc_enabled() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
void Config::set_has_agc_enabled() {
  _has_bits_[0] |= 0x00000200u;
}
void Config::clear_has_agc_enabled() {
  _has_bits_[0] &= ~0x00000200u;
}
void Config::clear_agc_enabled() {
  agc_enabled_ = false;
  clear_has_agc_enabled();
}
bool Config::agc_enabled() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.agc_enabled)
  return agc_enabled_;
}
void Config::set_agc_enabled(bool value) {
  set_has_agc_enabled();
  agc_enabled_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.agc_enabled)
}

// optional int32 agc_mode = 10;
bool Config::has_agc_mode() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
void Config::set_has_agc_mode() {
  _has_bits_[0] |= 0x00000800u;
}
void Config::clear_has_agc_mode() {
  _has_bits_[0] &= ~0x00000800u;
}
void Config::clear_agc_mode() {
  agc_mode_ = 0;
  clear_has_agc_mode();
}
::google::protobuf::int32 Config::agc_mode() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.agc_mode)
  return agc_mode_;
}
void Config::set_agc_mode(::google::protobuf::int32 value) {
  set_has_agc_mode();
  agc_mode_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.agc_mode)
}

// optional bool agc_limiter_enabled = 11;
bool Config::has_agc_limiter_enabled() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
void Config::set_has_agc_limiter_enabled() {
  _has_bits_[0] |= 0x00000400u;
}
void Config::clear_has_agc_limiter_enabled() {
  _has_bits_[0] &= ~0x00000400u;
}
void Config::clear_agc_limiter_enabled() {
  agc_limiter_enabled_ = false;
  clear_has_agc_limiter_enabled();
}
bool Config::agc_limiter_enabled() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.agc_limiter_enabled)
  return agc_limiter_enabled_;
}
void Config::set_agc_limiter_enabled(bool value) {
  set_has_agc_limiter_enabled();
  agc_limiter_enabled_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.agc_limiter_enabled)
}

// optional bool noise_robust_agc_enabled = 12;
bool Config::has_noise_robust_agc_enabled() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
void Config::set_has_noise_robust_agc_enabled() {
  _has_bits_[0] |= 0x00001000u;
}
void Config::clear_has_noise_robust_agc_enabled() {
  _has_bits_[0] &= ~0x00001000u;
}
void Config::clear_noise_robust_agc_enabled() {
  noise_robust_agc_enabled_ = false;
  clear_has_noise_robust_agc_enabled();
}
bool Config::noise_robust_agc_enabled() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.noise_robust_agc_enabled)
  return noise_robust_agc_enabled_;
}
void Config::set_noise_robust_agc_enabled(bool value) {
  set_has_noise_robust_agc_enabled();
  noise_robust_agc_enabled_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.noise_robust_agc_enabled)
}

// optional bool hpf_enabled = 13;
bool Config::has_hpf_enabled() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
void Config::set_has_hpf_enabled() {
  _has_bits_[0] |= 0x00002000u;
}
void Config::clear_has_hpf_enabled() {
  _has_bits_[0] &= ~0x00002000u;
}
void Config::clear_hpf_enabled() {
  hpf_enabled_ = false;
  clear_has_hpf_enabled();
}
bool Config::hpf_enabled() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.hpf_enabled)
  return hpf_enabled_;
}
void Config::set_hpf_enabled(bool value) {
  set_has_hpf_enabled();
  hpf_enabled_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.hpf_enabled)
}

// optional bool ns_enabled = 14;
bool Config::has_ns_enabled() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
void Config::set_has_ns_enabled() {
  _has_bits_[0] |= 0x00004000u;
}
void Config::clear_has_ns_enabled() {
  _has_bits_[0] &= ~0x00004000u;
}
void Config::clear_ns_enabled() {
  ns_enabled_ = false;
  clear_has_ns_enabled();
}
bool Config::ns_enabled() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.ns_enabled)
  return ns_enabled_;
}
void Config::set_ns_enabled(bool value) {
  set_has_ns_enabled();
  ns_enabled_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.ns_enabled)
}

// optional int32 ns_level = 15;
bool Config::has_ns_level() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
void Config::set_has_ns_level() {
  _has_bits_[0] |= 0x00010000u;
}
void Config::clear_has_ns_level() {
  _has_bits_[0] &= ~0x00010000u;
}
void Config::clear_ns_level() {
  ns_level_ = 0;
  clear_has_ns_level();
}
::google::protobuf::int32 Config::ns_level() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.ns_level)
  return ns_level_;
}
void Config::set_ns_level(::google::protobuf::int32 value) {
  set_has_ns_level();
  ns_level_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.ns_level)
}

// optional bool transient_suppression_enabled = 16;
bool Config::has_transient_suppression_enabled() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
void Config::set_has_transient_suppression_enabled() {
  _has_bits_[0] |= 0x00008000u;
}
void Config::clear_has_transient_suppression_enabled() {
  _has_bits_[0] &= ~0x00008000u;
}
void Config::clear_transient_suppression_enabled() {
  transient_suppression_enabled_ = false;
  clear_has_transient_suppression_enabled();
}
bool Config::transient_suppression_enabled() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.transient_suppression_enabled)
  return transient_suppression_enabled_;
}
void Config::set_transient_suppression_enabled(bool value) {
  set_has_transient_suppression_enabled();
  transient_suppression_enabled_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.transient_suppression_enabled)
}

// optional string experiments_description = 17;
bool Config::has_experiments_description() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void Config::set_has_experiments_description() {
  _has_bits_[0] |= 0x00000001u;
}
void Config::clear_has_experiments_description() {
  _has_bits_[0] &= ~0x00000001u;
}
void Config::clear_experiments_description() {
  experiments_description_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_experiments_description();
}
const ::std::string& Config::experiments_description() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.experiments_description)
  return experiments_description_.GetNoArena();
}
void Config::set_experiments_description(const ::std::string& value) {
  set_has_experiments_description();
  experiments_description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.experiments_description)
}
#if LANG_CXX11
void Config::set_experiments_description(::std::string&& value) {
  set_has_experiments_description();
  experiments_description_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:webrtc.audioproc.Config.experiments_description)
}
#endif
void Config::set_experiments_description(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_experiments_description();
  experiments_description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:webrtc.audioproc.Config.experiments_description)
}
void Config::set_experiments_description(const char* value, size_t size) {
  set_has_experiments_description();
  experiments_description_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:webrtc.audioproc.Config.experiments_description)
}
::std::string* Config::mutable_experiments_description() {
  set_has_experiments_description();
  // @@protoc_insertion_point(field_mutable:webrtc.audioproc.Config.experiments_description)
  return experiments_description_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* Config::release_experiments_description() {
  // @@protoc_insertion_point(field_release:webrtc.audioproc.Config.experiments_description)
  clear_has_experiments_description();
  return experiments_description_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void Config::set_allocated_experiments_description(::std::string* experiments_description) {
  if (experiments_description != NULL) {
    set_has_experiments_description();
  } else {
    clear_has_experiments_description();
  }
  experiments_description_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), experiments_description);
  // @@protoc_insertion_point(field_set_allocated:webrtc.audioproc.Config.experiments_description)
}

// optional bool intelligibility_enhancer_enabled = 18;
bool Config::has_intelligibility_enhancer_enabled() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
void Config::set_has_intelligibility_enhancer_enabled() {
  _has_bits_[0] |= 0x00020000u;
}
void Config::clear_has_intelligibility_enhancer_enabled() {
  _has_bits_[0] &= ~0x00020000u;
}
void Config::clear_intelligibility_enhancer_enabled() {
  intelligibility_enhancer_enabled_ = false;
  clear_has_intelligibility_enhancer_enabled();
}
bool Config::intelligibility_enhancer_enabled() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.intelligibility_enhancer_enabled)
  return intelligibility_enhancer_enabled_;
}
void Config::set_intelligibility_enhancer_enabled(bool value) {
  set_has_intelligibility_enhancer_enabled();
  intelligibility_enhancer_enabled_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.intelligibility_enhancer_enabled)
}

// optional bool pre_amplifier_enabled = 19;
bool Config::has_pre_amplifier_enabled() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
void Config::set_has_pre_amplifier_enabled() {
  _has_bits_[0] |= 0x00040000u;
}
void Config::clear_has_pre_amplifier_enabled() {
  _has_bits_[0] &= ~0x00040000u;
}
void Config::clear_pre_amplifier_enabled() {
  pre_amplifier_enabled_ = false;
  clear_has_pre_amplifier_enabled();
}
bool Config::pre_amplifier_enabled() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.pre_amplifier_enabled)
  return pre_amplifier_enabled_;
}
void Config::set_pre_amplifier_enabled(bool value) {
  set_has_pre_amplifier_enabled();
  pre_amplifier_enabled_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.pre_amplifier_enabled)
}

// optional float pre_amplifier_fixed_gain_factor = 20;
bool Config::has_pre_amplifier_fixed_gain_factor() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
void Config::set_has_pre_amplifier_fixed_gain_factor() {
  _has_bits_[0] |= 0x00080000u;
}
void Config::clear_has_pre_amplifier_fixed_gain_factor() {
  _has_bits_[0] &= ~0x00080000u;
}
void Config::clear_pre_amplifier_fixed_gain_factor() {
  pre_amplifier_fixed_gain_factor_ = 0;
  clear_has_pre_amplifier_fixed_gain_factor();
}
float Config::pre_amplifier_fixed_gain_factor() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.pre_amplifier_fixed_gain_factor)
  return pre_amplifier_fixed_gain_factor_;
}
void Config::set_pre_amplifier_fixed_gain_factor(float value) {
  set_has_pre_amplifier_fixed_gain_factor();
  pre_amplifier_fixed_gain_factor_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.pre_amplifier_fixed_gain_factor)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int Event::kTypeFieldNumber;
const int Event::kInitFieldNumber;
const int Event::kReverseStreamFieldNumber;
const int Event::kStreamFieldNumber;
const int Event::kConfigFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

Event::Event()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_debug_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.audioproc.Event)
}
Event::Event(const Event& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_init()) {
    init_ = new ::webrtc::audioproc::Init(*from.init_);
  } else {
    init_ = NULL;
  }
  if (from.has_reverse_stream()) {
    reverse_stream_ = new ::webrtc::audioproc::ReverseStream(*from.reverse_stream_);
  } else {
    reverse_stream_ = NULL;
  }
  if (from.has_stream()) {
    stream_ = new ::webrtc::audioproc::Stream(*from.stream_);
  } else {
    stream_ = NULL;
  }
  if (from.has_config()) {
    config_ = new ::webrtc::audioproc::Config(*from.config_);
  } else {
    config_ = NULL;
  }
  type_ = from.type_;
  // @@protoc_insertion_point(copy_constructor:webrtc.audioproc.Event)
}

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

Event::~Event() {
  // @@protoc_insertion_point(destructor:webrtc.audioproc.Event)
  SharedDtor();
}

void Event::SharedDtor() {
  if (this != internal_default_instance()) {
    delete init_;
  }
  if (this != internal_default_instance()) {
    delete reverse_stream_;
  }
  if (this != internal_default_instance()) {
    delete stream_;
  }
  if (this != internal_default_instance()) {
    delete config_;
  }
}

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

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

void Event::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.audioproc.Event)
  if (_has_bits_[0 / 32] & 15u) {
    if (has_init()) {
      GOOGLE_DCHECK(init_ != NULL);
      init_->::webrtc::audioproc::Init::Clear();
    }
    if (has_reverse_stream()) {
      GOOGLE_DCHECK(reverse_stream_ != NULL);
      reverse_stream_->::webrtc::audioproc::ReverseStream::Clear();
    }
    if (has_stream()) {
      GOOGLE_DCHECK(stream_ != NULL);
      stream_->::webrtc::audioproc::Stream::Clear();
    }
    if (has_config()) {
      GOOGLE_DCHECK(config_ != NULL);
      config_->::webrtc::audioproc::Config::Clear();
    }
  }
  type_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool Event::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.audioproc.Event)
  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)) {
      // required .webrtc.audioproc.Event.Type type = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::webrtc::audioproc::Event_Type_IsValid(value)) {
            set_type(static_cast< ::webrtc::audioproc::Event_Type >(value));
          } else {
            unknown_fields_stream.WriteVarint32(8u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.audioproc.Init init = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_init()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.audioproc.ReverseStream reverse_stream = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_reverse_stream()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.audioproc.Stream stream = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_stream()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.audioproc.Config config = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_config()));
        } 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.audioproc.Event)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.audioproc.Event)
  return false;
#undef DO_
}

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

  cached_has_bits = _has_bits_[0];
  // required .webrtc.audioproc.Event.Type type = 1;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

  // optional .webrtc.audioproc.Init init = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, *this->init_, output);
  }

  // optional .webrtc.audioproc.ReverseStream reverse_stream = 3;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      3, *this->reverse_stream_, output);
  }

  // optional .webrtc.audioproc.Stream stream = 4;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      4, *this->stream_, output);
  }

  // optional .webrtc.audioproc.Config config = 5;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      5, *this->config_, output);
  }

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

size_t Event::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:webrtc.audioproc.Event)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // required .webrtc.audioproc.Event.Type type = 1;
  if (has_type()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
  }
  if (_has_bits_[0 / 32] & 15u) {
    // optional .webrtc.audioproc.Init init = 2;
    if (has_init()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->init_);
    }

    // optional .webrtc.audioproc.ReverseStream reverse_stream = 3;
    if (has_reverse_stream()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->reverse_stream_);
    }

    // optional .webrtc.audioproc.Stream stream = 4;
    if (has_stream()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->stream_);
    }

    // optional .webrtc.audioproc.Config config = 5;
    if (has_config()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->config_);
    }

  }
  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 Event::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const Event*>(&from));
}

void Event::MergeFrom(const Event& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.audioproc.Event)
  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 & 31u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_init()->::webrtc::audioproc::Init::MergeFrom(from.init());
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_reverse_stream()->::webrtc::audioproc::ReverseStream::MergeFrom(from.reverse_stream());
    }
    if (cached_has_bits & 0x00000004u) {
      mutable_stream()->::webrtc::audioproc::Stream::MergeFrom(from.stream());
    }
    if (cached_has_bits & 0x00000008u) {
      mutable_config()->::webrtc::audioproc::Config::MergeFrom(from.config());
    }
    if (cached_has_bits & 0x00000010u) {
      type_ = from.type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

bool Event::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000010) != 0x00000010) return false;
  return true;
}

void Event::Swap(Event* other) {
  if (other == this) return;
  InternalSwap(other);
}
void Event::InternalSwap(Event* other) {
  std::swap(init_, other->init_);
  std::swap(reverse_stream_, other->reverse_stream_);
  std::swap(stream_, other->stream_);
  std::swap(config_, other->config_);
  std::swap(type_, other->type_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string Event::GetTypeName() const {
  return "webrtc.audioproc.Event";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// Event

// required .webrtc.audioproc.Event.Type type = 1;
bool Event::has_type() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void Event::set_has_type() {
  _has_bits_[0] |= 0x00000010u;
}
void Event::clear_has_type() {
  _has_bits_[0] &= ~0x00000010u;
}
void Event::clear_type() {
  type_ = 0;
  clear_has_type();
}
::webrtc::audioproc::Event_Type Event::type() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Event.type)
  return static_cast< ::webrtc::audioproc::Event_Type >(type_);
}
void Event::set_type(::webrtc::audioproc::Event_Type value) {
  assert(::webrtc::audioproc::Event_Type_IsValid(value));
  set_has_type();
  type_ = value;
  // @@protoc_insertion_point(field_set:webrtc.audioproc.Event.type)
}

// optional .webrtc.audioproc.Init init = 2;
bool Event::has_init() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void Event::set_has_init() {
  _has_bits_[0] |= 0x00000001u;
}
void Event::clear_has_init() {
  _has_bits_[0] &= ~0x00000001u;
}
void Event::clear_init() {
  if (init_ != NULL) init_->::webrtc::audioproc::Init::Clear();
  clear_has_init();
}
const ::webrtc::audioproc::Init& Event::init() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Event.init)
  return init_ != NULL ? *init_
                         : *::webrtc::audioproc::Init::internal_default_instance();
}
::webrtc::audioproc::Init* Event::mutable_init() {
  set_has_init();
  if (init_ == NULL) {
    init_ = new ::webrtc::audioproc::Init;
  }
  // @@protoc_insertion_point(field_mutable:webrtc.audioproc.Event.init)
  return init_;
}
::webrtc::audioproc::Init* Event::release_init() {
  // @@protoc_insertion_point(field_release:webrtc.audioproc.Event.init)
  clear_has_init();
  ::webrtc::audioproc::Init* temp = init_;
  init_ = NULL;
  return temp;
}
void Event::set_allocated_init(::webrtc::audioproc::Init* init) {
  delete init_;
  init_ = init;
  if (init) {
    set_has_init();
  } else {
    clear_has_init();
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audioproc.Event.init)
}

// optional .webrtc.audioproc.ReverseStream reverse_stream = 3;
bool Event::has_reverse_stream() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void Event::set_has_reverse_stream() {
  _has_bits_[0] |= 0x00000002u;
}
void Event::clear_has_reverse_stream() {
  _has_bits_[0] &= ~0x00000002u;
}
void Event::clear_reverse_stream() {
  if (reverse_stream_ != NULL) reverse_stream_->::webrtc::audioproc::ReverseStream::Clear();
  clear_has_reverse_stream();
}
const ::webrtc::audioproc::ReverseStream& Event::reverse_stream() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Event.reverse_stream)
  return reverse_stream_ != NULL ? *reverse_stream_
                         : *::webrtc::audioproc::ReverseStream::internal_default_instance();
}
::webrtc::audioproc::ReverseStream* Event::mutable_reverse_stream() {
  set_has_reverse_stream();
  if (reverse_stream_ == NULL) {
    reverse_stream_ = new ::webrtc::audioproc::ReverseStream;
  }
  // @@protoc_insertion_point(field_mutable:webrtc.audioproc.Event.reverse_stream)
  return reverse_stream_;
}
::webrtc::audioproc::ReverseStream* Event::release_reverse_stream() {
  // @@protoc_insertion_point(field_release:webrtc.audioproc.Event.reverse_stream)
  clear_has_reverse_stream();
  ::webrtc::audioproc::ReverseStream* temp = reverse_stream_;
  reverse_stream_ = NULL;
  return temp;
}
void Event::set_allocated_reverse_stream(::webrtc::audioproc::ReverseStream* reverse_stream) {
  delete reverse_stream_;
  reverse_stream_ = reverse_stream;
  if (reverse_stream) {
    set_has_reverse_stream();
  } else {
    clear_has_reverse_stream();
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audioproc.Event.reverse_stream)
}

// optional .webrtc.audioproc.Stream stream = 4;
bool Event::has_stream() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void Event::set_has_stream() {
  _has_bits_[0] |= 0x00000004u;
}
void Event::clear_has_stream() {
  _has_bits_[0] &= ~0x00000004u;
}
void Event::clear_stream() {
  if (stream_ != NULL) stream_->::webrtc::audioproc::Stream::Clear();
  clear_has_stream();
}
const ::webrtc::audioproc::Stream& Event::stream() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Event.stream)
  return stream_ != NULL ? *stream_
                         : *::webrtc::audioproc::Stream::internal_default_instance();
}
::webrtc::audioproc::Stream* Event::mutable_stream() {
  set_has_stream();
  if (stream_ == NULL) {
    stream_ = new ::webrtc::audioproc::Stream;
  }
  // @@protoc_insertion_point(field_mutable:webrtc.audioproc.Event.stream)
  return stream_;
}
::webrtc::audioproc::Stream* Event::release_stream() {
  // @@protoc_insertion_point(field_release:webrtc.audioproc.Event.stream)
  clear_has_stream();
  ::webrtc::audioproc::Stream* temp = stream_;
  stream_ = NULL;
  return temp;
}
void Event::set_allocated_stream(::webrtc::audioproc::Stream* stream) {
  delete stream_;
  stream_ = stream;
  if (stream) {
    set_has_stream();
  } else {
    clear_has_stream();
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audioproc.Event.stream)
}

// optional .webrtc.audioproc.Config config = 5;
bool Event::has_config() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void Event::set_has_config() {
  _has_bits_[0] |= 0x00000008u;
}
void Event::clear_has_config() {
  _has_bits_[0] &= ~0x00000008u;
}
void Event::clear_config() {
  if (config_ != NULL) config_->::webrtc::audioproc::Config::Clear();
  clear_has_config();
}
const ::webrtc::audioproc::Config& Event::config() const {
  // @@protoc_insertion_point(field_get:webrtc.audioproc.Event.config)
  return config_ != NULL ? *config_
                         : *::webrtc::audioproc::Config::internal_default_instance();
}
::webrtc::audioproc::Config* Event::mutable_config() {
  set_has_config();
  if (config_ == NULL) {
    config_ = new ::webrtc::audioproc::Config;
  }
  // @@protoc_insertion_point(field_mutable:webrtc.audioproc.Event.config)
  return config_;
}
::webrtc::audioproc::Config* Event::release_config() {
  // @@protoc_insertion_point(field_release:webrtc.audioproc.Event.config)
  clear_has_config();
  ::webrtc::audioproc::Config* temp = config_;
  config_ = NULL;
  return temp;
}
void Event::set_allocated_config(::webrtc::audioproc::Config* config) {
  delete config_;
  config_ = config;
  if (config) {
    set_has_config();
  } else {
    clear_has_config();
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.audioproc.Event.config)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// @@protoc_insertion_point(namespace_scope)

}  // namespace audioproc
}  // namespace webrtc

// @@protoc_insertion_point(global_scope)
