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

#include "rtc_event_log.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
extern PROTOBUF_INTERNAL_EXPORT_rtc_5fevent_5flog_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_AlrState_rtc_5fevent_5flog_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rtc_5fevent_5flog_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_AudioNetworkAdaptation_rtc_5fevent_5flog_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rtc_5fevent_5flog_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_AudioPlayoutEvent_rtc_5fevent_5flog_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rtc_5fevent_5flog_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_AudioReceiveConfig_rtc_5fevent_5flog_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rtc_5fevent_5flog_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_AudioSendConfig_rtc_5fevent_5flog_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rtc_5fevent_5flog_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_BweProbeCluster_rtc_5fevent_5flog_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rtc_5fevent_5flog_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_BweProbeResult_rtc_5fevent_5flog_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rtc_5fevent_5flog_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_DecoderConfig_rtc_5fevent_5flog_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rtc_5fevent_5flog_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_DelayBasedBweUpdate_rtc_5fevent_5flog_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rtc_5fevent_5flog_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_EncoderConfig_rtc_5fevent_5flog_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rtc_5fevent_5flog_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<15> scc_info_Event_rtc_5fevent_5flog_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rtc_5fevent_5flog_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_IceCandidatePairConfig_rtc_5fevent_5flog_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rtc_5fevent_5flog_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_IceCandidatePairEvent_rtc_5fevent_5flog_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rtc_5fevent_5flog_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_LossBasedBweUpdate_rtc_5fevent_5flog_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rtc_5fevent_5flog_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RtcpPacket_rtc_5fevent_5flog_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rtc_5fevent_5flog_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RtpHeaderExtension_rtc_5fevent_5flog_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rtc_5fevent_5flog_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RtpPacket_rtc_5fevent_5flog_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rtc_5fevent_5flog_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RtxConfig_rtc_5fevent_5flog_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rtc_5fevent_5flog_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_RtxMap_rtc_5fevent_5flog_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rtc_5fevent_5flog_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_VideoReceiveConfig_rtc_5fevent_5flog_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_rtc_5fevent_5flog_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_VideoSendConfig_rtc_5fevent_5flog_2eproto;
namespace webrtc {
namespace rtclog {
class EventStreamDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<EventStream> _instance;
} _EventStream_default_instance_;
class EventDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Event> _instance;
  const ::webrtc::rtclog::RtpPacket* rtp_packet_;
  const ::webrtc::rtclog::RtcpPacket* rtcp_packet_;
  const ::webrtc::rtclog::AudioPlayoutEvent* audio_playout_event_;
  const ::webrtc::rtclog::LossBasedBweUpdate* loss_based_bwe_update_;
  const ::webrtc::rtclog::DelayBasedBweUpdate* delay_based_bwe_update_;
  const ::webrtc::rtclog::VideoReceiveConfig* video_receiver_config_;
  const ::webrtc::rtclog::VideoSendConfig* video_sender_config_;
  const ::webrtc::rtclog::AudioReceiveConfig* audio_receiver_config_;
  const ::webrtc::rtclog::AudioSendConfig* audio_sender_config_;
  const ::webrtc::rtclog::AudioNetworkAdaptation* audio_network_adaptation_;
  const ::webrtc::rtclog::BweProbeCluster* probe_cluster_;
  const ::webrtc::rtclog::BweProbeResult* probe_result_;
  const ::webrtc::rtclog::AlrState* alr_state_;
  const ::webrtc::rtclog::IceCandidatePairConfig* ice_candidate_pair_config_;
  const ::webrtc::rtclog::IceCandidatePairEvent* ice_candidate_pair_event_;
} _Event_default_instance_;
class RtpPacketDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RtpPacket> _instance;
} _RtpPacket_default_instance_;
class RtcpPacketDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RtcpPacket> _instance;
} _RtcpPacket_default_instance_;
class AudioPlayoutEventDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<AudioPlayoutEvent> _instance;
} _AudioPlayoutEvent_default_instance_;
class LossBasedBweUpdateDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<LossBasedBweUpdate> _instance;
} _LossBasedBweUpdate_default_instance_;
class DelayBasedBweUpdateDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<DelayBasedBweUpdate> _instance;
} _DelayBasedBweUpdate_default_instance_;
class VideoReceiveConfigDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<VideoReceiveConfig> _instance;
} _VideoReceiveConfig_default_instance_;
class DecoderConfigDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<DecoderConfig> _instance;
} _DecoderConfig_default_instance_;
class RtpHeaderExtensionDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RtpHeaderExtension> _instance;
} _RtpHeaderExtension_default_instance_;
class RtxConfigDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RtxConfig> _instance;
} _RtxConfig_default_instance_;
class RtxMapDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RtxMap> _instance;
} _RtxMap_default_instance_;
class VideoSendConfigDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<VideoSendConfig> _instance;
} _VideoSendConfig_default_instance_;
class EncoderConfigDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<EncoderConfig> _instance;
} _EncoderConfig_default_instance_;
class AudioReceiveConfigDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<AudioReceiveConfig> _instance;
} _AudioReceiveConfig_default_instance_;
class AudioSendConfigDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<AudioSendConfig> _instance;
} _AudioSendConfig_default_instance_;
class AudioNetworkAdaptationDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<AudioNetworkAdaptation> _instance;
} _AudioNetworkAdaptation_default_instance_;
class BweProbeClusterDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<BweProbeCluster> _instance;
} _BweProbeCluster_default_instance_;
class BweProbeResultDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<BweProbeResult> _instance;
} _BweProbeResult_default_instance_;
class AlrStateDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<AlrState> _instance;
} _AlrState_default_instance_;
class IceCandidatePairConfigDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<IceCandidatePairConfig> _instance;
} _IceCandidatePairConfig_default_instance_;
class IceCandidatePairEventDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<IceCandidatePairEvent> _instance;
} _IceCandidatePairEvent_default_instance_;
}  // namespace rtclog
}  // namespace webrtc
static void InitDefaultsscc_info_AlrState_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_AlrState_default_instance_;
    new (ptr) ::webrtc::rtclog::AlrState();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::AlrState::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_AlrState_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_AlrState_rtc_5fevent_5flog_2eproto}, {}};

static void InitDefaultsscc_info_AudioNetworkAdaptation_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_AudioNetworkAdaptation_default_instance_;
    new (ptr) ::webrtc::rtclog::AudioNetworkAdaptation();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::AudioNetworkAdaptation::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_AudioNetworkAdaptation_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_AudioNetworkAdaptation_rtc_5fevent_5flog_2eproto}, {}};

static void InitDefaultsscc_info_AudioPlayoutEvent_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_AudioPlayoutEvent_default_instance_;
    new (ptr) ::webrtc::rtclog::AudioPlayoutEvent();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::AudioPlayoutEvent::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_AudioPlayoutEvent_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_AudioPlayoutEvent_rtc_5fevent_5flog_2eproto}, {}};

static void InitDefaultsscc_info_AudioReceiveConfig_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_AudioReceiveConfig_default_instance_;
    new (ptr) ::webrtc::rtclog::AudioReceiveConfig();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::AudioReceiveConfig::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_AudioReceiveConfig_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_AudioReceiveConfig_rtc_5fevent_5flog_2eproto}, {
      &scc_info_RtpHeaderExtension_rtc_5fevent_5flog_2eproto.base,}};

static void InitDefaultsscc_info_AudioSendConfig_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_AudioSendConfig_default_instance_;
    new (ptr) ::webrtc::rtclog::AudioSendConfig();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::AudioSendConfig::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_AudioSendConfig_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_AudioSendConfig_rtc_5fevent_5flog_2eproto}, {
      &scc_info_RtpHeaderExtension_rtc_5fevent_5flog_2eproto.base,}};

static void InitDefaultsscc_info_BweProbeCluster_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_BweProbeCluster_default_instance_;
    new (ptr) ::webrtc::rtclog::BweProbeCluster();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::BweProbeCluster::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_BweProbeCluster_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_BweProbeCluster_rtc_5fevent_5flog_2eproto}, {}};

static void InitDefaultsscc_info_BweProbeResult_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_BweProbeResult_default_instance_;
    new (ptr) ::webrtc::rtclog::BweProbeResult();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::BweProbeResult::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_BweProbeResult_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_BweProbeResult_rtc_5fevent_5flog_2eproto}, {}};

static void InitDefaultsscc_info_DecoderConfig_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_DecoderConfig_default_instance_;
    new (ptr) ::webrtc::rtclog::DecoderConfig();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::DecoderConfig::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_DecoderConfig_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_DecoderConfig_rtc_5fevent_5flog_2eproto}, {}};

static void InitDefaultsscc_info_DelayBasedBweUpdate_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_DelayBasedBweUpdate_default_instance_;
    new (ptr) ::webrtc::rtclog::DelayBasedBweUpdate();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::DelayBasedBweUpdate::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_DelayBasedBweUpdate_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_DelayBasedBweUpdate_rtc_5fevent_5flog_2eproto}, {}};

static void InitDefaultsscc_info_EncoderConfig_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_EncoderConfig_default_instance_;
    new (ptr) ::webrtc::rtclog::EncoderConfig();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::EncoderConfig::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_EncoderConfig_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_EncoderConfig_rtc_5fevent_5flog_2eproto}, {}};

static void InitDefaultsscc_info_Event_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_Event_default_instance_;
    new (ptr) ::webrtc::rtclog::Event();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::Event::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<15> scc_info_Event_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 15, InitDefaultsscc_info_Event_rtc_5fevent_5flog_2eproto}, {
      &scc_info_RtpPacket_rtc_5fevent_5flog_2eproto.base,
      &scc_info_RtcpPacket_rtc_5fevent_5flog_2eproto.base,
      &scc_info_AudioPlayoutEvent_rtc_5fevent_5flog_2eproto.base,
      &scc_info_LossBasedBweUpdate_rtc_5fevent_5flog_2eproto.base,
      &scc_info_DelayBasedBweUpdate_rtc_5fevent_5flog_2eproto.base,
      &scc_info_VideoReceiveConfig_rtc_5fevent_5flog_2eproto.base,
      &scc_info_VideoSendConfig_rtc_5fevent_5flog_2eproto.base,
      &scc_info_AudioReceiveConfig_rtc_5fevent_5flog_2eproto.base,
      &scc_info_AudioSendConfig_rtc_5fevent_5flog_2eproto.base,
      &scc_info_AudioNetworkAdaptation_rtc_5fevent_5flog_2eproto.base,
      &scc_info_BweProbeCluster_rtc_5fevent_5flog_2eproto.base,
      &scc_info_BweProbeResult_rtc_5fevent_5flog_2eproto.base,
      &scc_info_AlrState_rtc_5fevent_5flog_2eproto.base,
      &scc_info_IceCandidatePairConfig_rtc_5fevent_5flog_2eproto.base,
      &scc_info_IceCandidatePairEvent_rtc_5fevent_5flog_2eproto.base,}};

static void InitDefaultsscc_info_EventStream_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_EventStream_default_instance_;
    new (ptr) ::webrtc::rtclog::EventStream();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::EventStream::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_EventStream_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_EventStream_rtc_5fevent_5flog_2eproto}, {
      &scc_info_Event_rtc_5fevent_5flog_2eproto.base,}};

static void InitDefaultsscc_info_IceCandidatePairConfig_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_IceCandidatePairConfig_default_instance_;
    new (ptr) ::webrtc::rtclog::IceCandidatePairConfig();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::IceCandidatePairConfig::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_IceCandidatePairConfig_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_IceCandidatePairConfig_rtc_5fevent_5flog_2eproto}, {}};

static void InitDefaultsscc_info_IceCandidatePairEvent_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_IceCandidatePairEvent_default_instance_;
    new (ptr) ::webrtc::rtclog::IceCandidatePairEvent();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::IceCandidatePairEvent::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_IceCandidatePairEvent_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_IceCandidatePairEvent_rtc_5fevent_5flog_2eproto}, {}};

static void InitDefaultsscc_info_LossBasedBweUpdate_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_LossBasedBweUpdate_default_instance_;
    new (ptr) ::webrtc::rtclog::LossBasedBweUpdate();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::LossBasedBweUpdate::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_LossBasedBweUpdate_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_LossBasedBweUpdate_rtc_5fevent_5flog_2eproto}, {}};

static void InitDefaultsscc_info_RtcpPacket_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_RtcpPacket_default_instance_;
    new (ptr) ::webrtc::rtclog::RtcpPacket();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::RtcpPacket::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RtcpPacket_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_RtcpPacket_rtc_5fevent_5flog_2eproto}, {}};

static void InitDefaultsscc_info_RtpHeaderExtension_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_RtpHeaderExtension_default_instance_;
    new (ptr) ::webrtc::rtclog::RtpHeaderExtension();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::RtpHeaderExtension::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RtpHeaderExtension_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_RtpHeaderExtension_rtc_5fevent_5flog_2eproto}, {}};

static void InitDefaultsscc_info_RtpPacket_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_RtpPacket_default_instance_;
    new (ptr) ::webrtc::rtclog::RtpPacket();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::RtpPacket::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RtpPacket_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_RtpPacket_rtc_5fevent_5flog_2eproto}, {}};

static void InitDefaultsscc_info_RtxConfig_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_RtxConfig_default_instance_;
    new (ptr) ::webrtc::rtclog::RtxConfig();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::RtxConfig::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RtxConfig_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_RtxConfig_rtc_5fevent_5flog_2eproto}, {}};

static void InitDefaultsscc_info_RtxMap_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_RtxMap_default_instance_;
    new (ptr) ::webrtc::rtclog::RtxMap();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::RtxMap::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_RtxMap_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_RtxMap_rtc_5fevent_5flog_2eproto}, {
      &scc_info_RtxConfig_rtc_5fevent_5flog_2eproto.base,}};

static void InitDefaultsscc_info_VideoReceiveConfig_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_VideoReceiveConfig_default_instance_;
    new (ptr) ::webrtc::rtclog::VideoReceiveConfig();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::VideoReceiveConfig::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_VideoReceiveConfig_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, InitDefaultsscc_info_VideoReceiveConfig_rtc_5fevent_5flog_2eproto}, {
      &scc_info_RtxMap_rtc_5fevent_5flog_2eproto.base,
      &scc_info_RtpHeaderExtension_rtc_5fevent_5flog_2eproto.base,
      &scc_info_DecoderConfig_rtc_5fevent_5flog_2eproto.base,}};

static void InitDefaultsscc_info_VideoSendConfig_rtc_5fevent_5flog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::webrtc::rtclog::_VideoSendConfig_default_instance_;
    new (ptr) ::webrtc::rtclog::VideoSendConfig();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::webrtc::rtclog::VideoSendConfig::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_VideoSendConfig_rtc_5fevent_5flog_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_VideoSendConfig_rtc_5fevent_5flog_2eproto}, {
      &scc_info_RtpHeaderExtension_rtc_5fevent_5flog_2eproto.base,
      &scc_info_EncoderConfig_rtc_5fevent_5flog_2eproto.base,}};

namespace webrtc {
namespace rtclog {
bool Event_EventType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> Event_EventType_strings[18] = {};

static const char Event_EventType_names[] =
  "ALR_STATE_EVENT"
  "AUDIO_NETWORK_ADAPTATION_EVENT"
  "AUDIO_PLAYOUT_EVENT"
  "AUDIO_RECEIVER_CONFIG_EVENT"
  "AUDIO_SENDER_CONFIG_EVENT"
  "BWE_PROBE_CLUSTER_CREATED_EVENT"
  "BWE_PROBE_RESULT_EVENT"
  "DELAY_BASED_BWE_UPDATE"
  "ICE_CANDIDATE_PAIR_CONFIG"
  "ICE_CANDIDATE_PAIR_EVENT"
  "LOG_END"
  "LOG_START"
  "LOSS_BASED_BWE_UPDATE"
  "RTCP_EVENT"
  "RTP_EVENT"
  "UNKNOWN_EVENT"
  "VIDEO_RECEIVER_CONFIG_EVENT"
  "VIDEO_SENDER_CONFIG_EVENT";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry Event_EventType_entries[] = {
  { {Event_EventType_names + 0, 15}, 19 },
  { {Event_EventType_names + 15, 30}, 16 },
  { {Event_EventType_names + 45, 19}, 5 },
  { {Event_EventType_names + 64, 27}, 10 },
  { {Event_EventType_names + 91, 25}, 11 },
  { {Event_EventType_names + 116, 31}, 17 },
  { {Event_EventType_names + 147, 22}, 18 },
  { {Event_EventType_names + 169, 22}, 7 },
  { {Event_EventType_names + 191, 25}, 20 },
  { {Event_EventType_names + 216, 24}, 21 },
  { {Event_EventType_names + 240, 7}, 2 },
  { {Event_EventType_names + 247, 9}, 1 },
  { {Event_EventType_names + 256, 21}, 6 },
  { {Event_EventType_names + 277, 10}, 4 },
  { {Event_EventType_names + 287, 9}, 3 },
  { {Event_EventType_names + 296, 13}, 0 },
  { {Event_EventType_names + 309, 27}, 8 },
  { {Event_EventType_names + 336, 25}, 9 },
};

static const int Event_EventType_entries_by_number[] = {
  15, // 0 -> UNKNOWN_EVENT
  11, // 1 -> LOG_START
  10, // 2 -> LOG_END
  14, // 3 -> RTP_EVENT
  13, // 4 -> RTCP_EVENT
  2, // 5 -> AUDIO_PLAYOUT_EVENT
  12, // 6 -> LOSS_BASED_BWE_UPDATE
  7, // 7 -> DELAY_BASED_BWE_UPDATE
  16, // 8 -> VIDEO_RECEIVER_CONFIG_EVENT
  17, // 9 -> VIDEO_SENDER_CONFIG_EVENT
  3, // 10 -> AUDIO_RECEIVER_CONFIG_EVENT
  4, // 11 -> AUDIO_SENDER_CONFIG_EVENT
  1, // 16 -> AUDIO_NETWORK_ADAPTATION_EVENT
  5, // 17 -> BWE_PROBE_CLUSTER_CREATED_EVENT
  6, // 18 -> BWE_PROBE_RESULT_EVENT
  0, // 19 -> ALR_STATE_EVENT
  8, // 20 -> ICE_CANDIDATE_PAIR_CONFIG
  9, // 21 -> ICE_CANDIDATE_PAIR_EVENT
};

const std::string& Event_EventType_Name(
    Event_EventType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          Event_EventType_entries,
          Event_EventType_entries_by_number,
          18, Event_EventType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      Event_EventType_entries,
      Event_EventType_entries_by_number,
      18, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     Event_EventType_strings[idx].get();
}
bool Event_EventType_Parse(
    const std::string& name, Event_EventType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      Event_EventType_entries, 18, name, &int_value);
  if (success) {
    *value = static_cast<Event_EventType>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr Event_EventType Event::UNKNOWN_EVENT;
constexpr Event_EventType Event::LOG_START;
constexpr Event_EventType Event::LOG_END;
constexpr Event_EventType Event::RTP_EVENT;
constexpr Event_EventType Event::RTCP_EVENT;
constexpr Event_EventType Event::AUDIO_PLAYOUT_EVENT;
constexpr Event_EventType Event::LOSS_BASED_BWE_UPDATE;
constexpr Event_EventType Event::DELAY_BASED_BWE_UPDATE;
constexpr Event_EventType Event::VIDEO_RECEIVER_CONFIG_EVENT;
constexpr Event_EventType Event::VIDEO_SENDER_CONFIG_EVENT;
constexpr Event_EventType Event::AUDIO_RECEIVER_CONFIG_EVENT;
constexpr Event_EventType Event::AUDIO_SENDER_CONFIG_EVENT;
constexpr Event_EventType Event::AUDIO_NETWORK_ADAPTATION_EVENT;
constexpr Event_EventType Event::BWE_PROBE_CLUSTER_CREATED_EVENT;
constexpr Event_EventType Event::BWE_PROBE_RESULT_EVENT;
constexpr Event_EventType Event::ALR_STATE_EVENT;
constexpr Event_EventType Event::ICE_CANDIDATE_PAIR_CONFIG;
constexpr Event_EventType Event::ICE_CANDIDATE_PAIR_EVENT;
constexpr Event_EventType Event::EventType_MIN;
constexpr Event_EventType Event::EventType_MAX;
constexpr int Event::EventType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
bool DelayBasedBweUpdate_DetectorState_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> DelayBasedBweUpdate_DetectorState_strings[3] = {};

static const char DelayBasedBweUpdate_DetectorState_names[] =
  "BWE_NORMAL"
  "BWE_OVERUSING"
  "BWE_UNDERUSING";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DelayBasedBweUpdate_DetectorState_entries[] = {
  { {DelayBasedBweUpdate_DetectorState_names + 0, 10}, 0 },
  { {DelayBasedBweUpdate_DetectorState_names + 10, 13}, 2 },
  { {DelayBasedBweUpdate_DetectorState_names + 23, 14}, 1 },
};

static const int DelayBasedBweUpdate_DetectorState_entries_by_number[] = {
  0, // 0 -> BWE_NORMAL
  2, // 1 -> BWE_UNDERUSING
  1, // 2 -> BWE_OVERUSING
};

const std::string& DelayBasedBweUpdate_DetectorState_Name(
    DelayBasedBweUpdate_DetectorState value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          DelayBasedBweUpdate_DetectorState_entries,
          DelayBasedBweUpdate_DetectorState_entries_by_number,
          3, DelayBasedBweUpdate_DetectorState_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      DelayBasedBweUpdate_DetectorState_entries,
      DelayBasedBweUpdate_DetectorState_entries_by_number,
      3, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     DelayBasedBweUpdate_DetectorState_strings[idx].get();
}
bool DelayBasedBweUpdate_DetectorState_Parse(
    const std::string& name, DelayBasedBweUpdate_DetectorState* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      DelayBasedBweUpdate_DetectorState_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<DelayBasedBweUpdate_DetectorState>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr DelayBasedBweUpdate_DetectorState DelayBasedBweUpdate::BWE_NORMAL;
constexpr DelayBasedBweUpdate_DetectorState DelayBasedBweUpdate::BWE_UNDERUSING;
constexpr DelayBasedBweUpdate_DetectorState DelayBasedBweUpdate::BWE_OVERUSING;
constexpr DelayBasedBweUpdate_DetectorState DelayBasedBweUpdate::DetectorState_MIN;
constexpr DelayBasedBweUpdate_DetectorState DelayBasedBweUpdate::DetectorState_MAX;
constexpr int DelayBasedBweUpdate::DetectorState_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
bool VideoReceiveConfig_RtcpMode_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> VideoReceiveConfig_RtcpMode_strings[2] = {};

static const char VideoReceiveConfig_RtcpMode_names[] =
  "RTCP_COMPOUND"
  "RTCP_REDUCEDSIZE";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry VideoReceiveConfig_RtcpMode_entries[] = {
  { {VideoReceiveConfig_RtcpMode_names + 0, 13}, 1 },
  { {VideoReceiveConfig_RtcpMode_names + 13, 16}, 2 },
};

static const int VideoReceiveConfig_RtcpMode_entries_by_number[] = {
  0, // 1 -> RTCP_COMPOUND
  1, // 2 -> RTCP_REDUCEDSIZE
};

const std::string& VideoReceiveConfig_RtcpMode_Name(
    VideoReceiveConfig_RtcpMode value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          VideoReceiveConfig_RtcpMode_entries,
          VideoReceiveConfig_RtcpMode_entries_by_number,
          2, VideoReceiveConfig_RtcpMode_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      VideoReceiveConfig_RtcpMode_entries,
      VideoReceiveConfig_RtcpMode_entries_by_number,
      2, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     VideoReceiveConfig_RtcpMode_strings[idx].get();
}
bool VideoReceiveConfig_RtcpMode_Parse(
    const std::string& name, VideoReceiveConfig_RtcpMode* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      VideoReceiveConfig_RtcpMode_entries, 2, name, &int_value);
  if (success) {
    *value = static_cast<VideoReceiveConfig_RtcpMode>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr VideoReceiveConfig_RtcpMode VideoReceiveConfig::RTCP_COMPOUND;
constexpr VideoReceiveConfig_RtcpMode VideoReceiveConfig::RTCP_REDUCEDSIZE;
constexpr VideoReceiveConfig_RtcpMode VideoReceiveConfig::RtcpMode_MIN;
constexpr VideoReceiveConfig_RtcpMode VideoReceiveConfig::RtcpMode_MAX;
constexpr int VideoReceiveConfig::RtcpMode_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
bool BweProbeResult_ResultType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> BweProbeResult_ResultType_strings[4] = {};

static const char BweProbeResult_ResultType_names[] =
  "INVALID_SEND_RECEIVE_INTERVAL"
  "INVALID_SEND_RECEIVE_RATIO"
  "SUCCESS"
  "TIMEOUT";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry BweProbeResult_ResultType_entries[] = {
  { {BweProbeResult_ResultType_names + 0, 29}, 1 },
  { {BweProbeResult_ResultType_names + 29, 26}, 2 },
  { {BweProbeResult_ResultType_names + 55, 7}, 0 },
  { {BweProbeResult_ResultType_names + 62, 7}, 3 },
};

static const int BweProbeResult_ResultType_entries_by_number[] = {
  2, // 0 -> SUCCESS
  0, // 1 -> INVALID_SEND_RECEIVE_INTERVAL
  1, // 2 -> INVALID_SEND_RECEIVE_RATIO
  3, // 3 -> TIMEOUT
};

const std::string& BweProbeResult_ResultType_Name(
    BweProbeResult_ResultType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          BweProbeResult_ResultType_entries,
          BweProbeResult_ResultType_entries_by_number,
          4, BweProbeResult_ResultType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      BweProbeResult_ResultType_entries,
      BweProbeResult_ResultType_entries_by_number,
      4, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     BweProbeResult_ResultType_strings[idx].get();
}
bool BweProbeResult_ResultType_Parse(
    const std::string& name, BweProbeResult_ResultType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      BweProbeResult_ResultType_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<BweProbeResult_ResultType>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr BweProbeResult_ResultType BweProbeResult::SUCCESS;
constexpr BweProbeResult_ResultType BweProbeResult::INVALID_SEND_RECEIVE_INTERVAL;
constexpr BweProbeResult_ResultType BweProbeResult::INVALID_SEND_RECEIVE_RATIO;
constexpr BweProbeResult_ResultType BweProbeResult::TIMEOUT;
constexpr BweProbeResult_ResultType BweProbeResult::ResultType_MIN;
constexpr BweProbeResult_ResultType BweProbeResult::ResultType_MAX;
constexpr int BweProbeResult::ResultType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
bool IceCandidatePairConfig_IceCandidatePairConfigType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> IceCandidatePairConfig_IceCandidatePairConfigType_strings[4] = {};

static const char IceCandidatePairConfig_IceCandidatePairConfigType_names[] =
  "ADDED"
  "DESTROYED"
  "SELECTED"
  "UPDATED";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry IceCandidatePairConfig_IceCandidatePairConfigType_entries[] = {
  { {IceCandidatePairConfig_IceCandidatePairConfigType_names + 0, 5}, 0 },
  { {IceCandidatePairConfig_IceCandidatePairConfigType_names + 5, 9}, 2 },
  { {IceCandidatePairConfig_IceCandidatePairConfigType_names + 14, 8}, 3 },
  { {IceCandidatePairConfig_IceCandidatePairConfigType_names + 22, 7}, 1 },
};

static const int IceCandidatePairConfig_IceCandidatePairConfigType_entries_by_number[] = {
  0, // 0 -> ADDED
  3, // 1 -> UPDATED
  1, // 2 -> DESTROYED
  2, // 3 -> SELECTED
};

const std::string& IceCandidatePairConfig_IceCandidatePairConfigType_Name(
    IceCandidatePairConfig_IceCandidatePairConfigType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          IceCandidatePairConfig_IceCandidatePairConfigType_entries,
          IceCandidatePairConfig_IceCandidatePairConfigType_entries_by_number,
          4, IceCandidatePairConfig_IceCandidatePairConfigType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      IceCandidatePairConfig_IceCandidatePairConfigType_entries,
      IceCandidatePairConfig_IceCandidatePairConfigType_entries_by_number,
      4, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     IceCandidatePairConfig_IceCandidatePairConfigType_strings[idx].get();
}
bool IceCandidatePairConfig_IceCandidatePairConfigType_Parse(
    const std::string& name, IceCandidatePairConfig_IceCandidatePairConfigType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      IceCandidatePairConfig_IceCandidatePairConfigType_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<IceCandidatePairConfig_IceCandidatePairConfigType>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr IceCandidatePairConfig_IceCandidatePairConfigType IceCandidatePairConfig::ADDED;
constexpr IceCandidatePairConfig_IceCandidatePairConfigType IceCandidatePairConfig::UPDATED;
constexpr IceCandidatePairConfig_IceCandidatePairConfigType IceCandidatePairConfig::DESTROYED;
constexpr IceCandidatePairConfig_IceCandidatePairConfigType IceCandidatePairConfig::SELECTED;
constexpr IceCandidatePairConfig_IceCandidatePairConfigType IceCandidatePairConfig::IceCandidatePairConfigType_MIN;
constexpr IceCandidatePairConfig_IceCandidatePairConfigType IceCandidatePairConfig::IceCandidatePairConfigType_MAX;
constexpr int IceCandidatePairConfig::IceCandidatePairConfigType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
bool IceCandidatePairConfig_IceCandidateType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> IceCandidatePairConfig_IceCandidateType_strings[5] = {};

static const char IceCandidatePairConfig_IceCandidateType_names[] =
  "LOCAL"
  "PRFLX"
  "RELAY"
  "STUN"
  "UNKNOWN_CANDIDATE_TYPE";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry IceCandidatePairConfig_IceCandidateType_entries[] = {
  { {IceCandidatePairConfig_IceCandidateType_names + 0, 5}, 0 },
  { {IceCandidatePairConfig_IceCandidateType_names + 5, 5}, 2 },
  { {IceCandidatePairConfig_IceCandidateType_names + 10, 5}, 3 },
  { {IceCandidatePairConfig_IceCandidateType_names + 15, 4}, 1 },
  { {IceCandidatePairConfig_IceCandidateType_names + 19, 22}, 4 },
};

static const int IceCandidatePairConfig_IceCandidateType_entries_by_number[] = {
  0, // 0 -> LOCAL
  3, // 1 -> STUN
  1, // 2 -> PRFLX
  2, // 3 -> RELAY
  4, // 4 -> UNKNOWN_CANDIDATE_TYPE
};

const std::string& IceCandidatePairConfig_IceCandidateType_Name(
    IceCandidatePairConfig_IceCandidateType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          IceCandidatePairConfig_IceCandidateType_entries,
          IceCandidatePairConfig_IceCandidateType_entries_by_number,
          5, IceCandidatePairConfig_IceCandidateType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      IceCandidatePairConfig_IceCandidateType_entries,
      IceCandidatePairConfig_IceCandidateType_entries_by_number,
      5, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     IceCandidatePairConfig_IceCandidateType_strings[idx].get();
}
bool IceCandidatePairConfig_IceCandidateType_Parse(
    const std::string& name, IceCandidatePairConfig_IceCandidateType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      IceCandidatePairConfig_IceCandidateType_entries, 5, name, &int_value);
  if (success) {
    *value = static_cast<IceCandidatePairConfig_IceCandidateType>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr IceCandidatePairConfig_IceCandidateType IceCandidatePairConfig::LOCAL;
constexpr IceCandidatePairConfig_IceCandidateType IceCandidatePairConfig::STUN;
constexpr IceCandidatePairConfig_IceCandidateType IceCandidatePairConfig::PRFLX;
constexpr IceCandidatePairConfig_IceCandidateType IceCandidatePairConfig::RELAY;
constexpr IceCandidatePairConfig_IceCandidateType IceCandidatePairConfig::UNKNOWN_CANDIDATE_TYPE;
constexpr IceCandidatePairConfig_IceCandidateType IceCandidatePairConfig::IceCandidateType_MIN;
constexpr IceCandidatePairConfig_IceCandidateType IceCandidatePairConfig::IceCandidateType_MAX;
constexpr int IceCandidatePairConfig::IceCandidateType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
bool IceCandidatePairConfig_Protocol_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> IceCandidatePairConfig_Protocol_strings[5] = {};

static const char IceCandidatePairConfig_Protocol_names[] =
  "SSLTCP"
  "TCP"
  "TLS"
  "UDP"
  "UNKNOWN_PROTOCOL";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry IceCandidatePairConfig_Protocol_entries[] = {
  { {IceCandidatePairConfig_Protocol_names + 0, 6}, 2 },
  { {IceCandidatePairConfig_Protocol_names + 6, 3}, 1 },
  { {IceCandidatePairConfig_Protocol_names + 9, 3}, 3 },
  { {IceCandidatePairConfig_Protocol_names + 12, 3}, 0 },
  { {IceCandidatePairConfig_Protocol_names + 15, 16}, 4 },
};

static const int IceCandidatePairConfig_Protocol_entries_by_number[] = {
  3, // 0 -> UDP
  1, // 1 -> TCP
  0, // 2 -> SSLTCP
  2, // 3 -> TLS
  4, // 4 -> UNKNOWN_PROTOCOL
};

const std::string& IceCandidatePairConfig_Protocol_Name(
    IceCandidatePairConfig_Protocol value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          IceCandidatePairConfig_Protocol_entries,
          IceCandidatePairConfig_Protocol_entries_by_number,
          5, IceCandidatePairConfig_Protocol_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      IceCandidatePairConfig_Protocol_entries,
      IceCandidatePairConfig_Protocol_entries_by_number,
      5, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     IceCandidatePairConfig_Protocol_strings[idx].get();
}
bool IceCandidatePairConfig_Protocol_Parse(
    const std::string& name, IceCandidatePairConfig_Protocol* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      IceCandidatePairConfig_Protocol_entries, 5, name, &int_value);
  if (success) {
    *value = static_cast<IceCandidatePairConfig_Protocol>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr IceCandidatePairConfig_Protocol IceCandidatePairConfig::UDP;
constexpr IceCandidatePairConfig_Protocol IceCandidatePairConfig::TCP;
constexpr IceCandidatePairConfig_Protocol IceCandidatePairConfig::SSLTCP;
constexpr IceCandidatePairConfig_Protocol IceCandidatePairConfig::TLS;
constexpr IceCandidatePairConfig_Protocol IceCandidatePairConfig::UNKNOWN_PROTOCOL;
constexpr IceCandidatePairConfig_Protocol IceCandidatePairConfig::Protocol_MIN;
constexpr IceCandidatePairConfig_Protocol IceCandidatePairConfig::Protocol_MAX;
constexpr int IceCandidatePairConfig::Protocol_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
bool IceCandidatePairConfig_AddressFamily_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> IceCandidatePairConfig_AddressFamily_strings[3] = {};

static const char IceCandidatePairConfig_AddressFamily_names[] =
  "IPV4"
  "IPV6"
  "UNKNOWN_ADDRESS_FAMILY";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry IceCandidatePairConfig_AddressFamily_entries[] = {
  { {IceCandidatePairConfig_AddressFamily_names + 0, 4}, 0 },
  { {IceCandidatePairConfig_AddressFamily_names + 4, 4}, 1 },
  { {IceCandidatePairConfig_AddressFamily_names + 8, 22}, 2 },
};

static const int IceCandidatePairConfig_AddressFamily_entries_by_number[] = {
  0, // 0 -> IPV4
  1, // 1 -> IPV6
  2, // 2 -> UNKNOWN_ADDRESS_FAMILY
};

const std::string& IceCandidatePairConfig_AddressFamily_Name(
    IceCandidatePairConfig_AddressFamily value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          IceCandidatePairConfig_AddressFamily_entries,
          IceCandidatePairConfig_AddressFamily_entries_by_number,
          3, IceCandidatePairConfig_AddressFamily_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      IceCandidatePairConfig_AddressFamily_entries,
      IceCandidatePairConfig_AddressFamily_entries_by_number,
      3, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     IceCandidatePairConfig_AddressFamily_strings[idx].get();
}
bool IceCandidatePairConfig_AddressFamily_Parse(
    const std::string& name, IceCandidatePairConfig_AddressFamily* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      IceCandidatePairConfig_AddressFamily_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<IceCandidatePairConfig_AddressFamily>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr IceCandidatePairConfig_AddressFamily IceCandidatePairConfig::IPV4;
constexpr IceCandidatePairConfig_AddressFamily IceCandidatePairConfig::IPV6;
constexpr IceCandidatePairConfig_AddressFamily IceCandidatePairConfig::UNKNOWN_ADDRESS_FAMILY;
constexpr IceCandidatePairConfig_AddressFamily IceCandidatePairConfig::AddressFamily_MIN;
constexpr IceCandidatePairConfig_AddressFamily IceCandidatePairConfig::AddressFamily_MAX;
constexpr int IceCandidatePairConfig::AddressFamily_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
bool IceCandidatePairConfig_NetworkType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> IceCandidatePairConfig_NetworkType_strings[6] = {};

static const char IceCandidatePairConfig_NetworkType_names[] =
  "CELLULAR"
  "ETHERNET"
  "LOOPBACK"
  "UNKNOWN_NETWORK_TYPE"
  "VPN"
  "WIFI";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry IceCandidatePairConfig_NetworkType_entries[] = {
  { {IceCandidatePairConfig_NetworkType_names + 0, 8}, 4 },
  { {IceCandidatePairConfig_NetworkType_names + 8, 8}, 0 },
  { {IceCandidatePairConfig_NetworkType_names + 16, 8}, 1 },
  { {IceCandidatePairConfig_NetworkType_names + 24, 20}, 5 },
  { {IceCandidatePairConfig_NetworkType_names + 44, 3}, 3 },
  { {IceCandidatePairConfig_NetworkType_names + 47, 4}, 2 },
};

static const int IceCandidatePairConfig_NetworkType_entries_by_number[] = {
  1, // 0 -> ETHERNET
  2, // 1 -> LOOPBACK
  5, // 2 -> WIFI
  4, // 3 -> VPN
  0, // 4 -> CELLULAR
  3, // 5 -> UNKNOWN_NETWORK_TYPE
};

const std::string& IceCandidatePairConfig_NetworkType_Name(
    IceCandidatePairConfig_NetworkType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          IceCandidatePairConfig_NetworkType_entries,
          IceCandidatePairConfig_NetworkType_entries_by_number,
          6, IceCandidatePairConfig_NetworkType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      IceCandidatePairConfig_NetworkType_entries,
      IceCandidatePairConfig_NetworkType_entries_by_number,
      6, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     IceCandidatePairConfig_NetworkType_strings[idx].get();
}
bool IceCandidatePairConfig_NetworkType_Parse(
    const std::string& name, IceCandidatePairConfig_NetworkType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      IceCandidatePairConfig_NetworkType_entries, 6, name, &int_value);
  if (success) {
    *value = static_cast<IceCandidatePairConfig_NetworkType>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::ETHERNET;
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::LOOPBACK;
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::WIFI;
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::VPN;
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::CELLULAR;
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::UNKNOWN_NETWORK_TYPE;
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::NetworkType_MIN;
constexpr IceCandidatePairConfig_NetworkType IceCandidatePairConfig::NetworkType_MAX;
constexpr int IceCandidatePairConfig::NetworkType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
bool IceCandidatePairEvent_IceCandidatePairEventType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> IceCandidatePairEvent_IceCandidatePairEventType_strings[4] = {};

static const char IceCandidatePairEvent_IceCandidatePairEventType_names[] =
  "CHECK_RECEIVED"
  "CHECK_RESPONSE_RECEIVED"
  "CHECK_RESPONSE_SENT"
  "CHECK_SENT";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry IceCandidatePairEvent_IceCandidatePairEventType_entries[] = {
  { {IceCandidatePairEvent_IceCandidatePairEventType_names + 0, 14}, 1 },
  { {IceCandidatePairEvent_IceCandidatePairEventType_names + 14, 23}, 3 },
  { {IceCandidatePairEvent_IceCandidatePairEventType_names + 37, 19}, 2 },
  { {IceCandidatePairEvent_IceCandidatePairEventType_names + 56, 10}, 0 },
};

static const int IceCandidatePairEvent_IceCandidatePairEventType_entries_by_number[] = {
  3, // 0 -> CHECK_SENT
  0, // 1 -> CHECK_RECEIVED
  2, // 2 -> CHECK_RESPONSE_SENT
  1, // 3 -> CHECK_RESPONSE_RECEIVED
};

const std::string& IceCandidatePairEvent_IceCandidatePairEventType_Name(
    IceCandidatePairEvent_IceCandidatePairEventType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          IceCandidatePairEvent_IceCandidatePairEventType_entries,
          IceCandidatePairEvent_IceCandidatePairEventType_entries_by_number,
          4, IceCandidatePairEvent_IceCandidatePairEventType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      IceCandidatePairEvent_IceCandidatePairEventType_entries,
      IceCandidatePairEvent_IceCandidatePairEventType_entries_by_number,
      4, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     IceCandidatePairEvent_IceCandidatePairEventType_strings[idx].get();
}
bool IceCandidatePairEvent_IceCandidatePairEventType_Parse(
    const std::string& name, IceCandidatePairEvent_IceCandidatePairEventType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      IceCandidatePairEvent_IceCandidatePairEventType_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<IceCandidatePairEvent_IceCandidatePairEventType>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr IceCandidatePairEvent_IceCandidatePairEventType IceCandidatePairEvent::CHECK_SENT;
constexpr IceCandidatePairEvent_IceCandidatePairEventType IceCandidatePairEvent::CHECK_RECEIVED;
constexpr IceCandidatePairEvent_IceCandidatePairEventType IceCandidatePairEvent::CHECK_RESPONSE_SENT;
constexpr IceCandidatePairEvent_IceCandidatePairEventType IceCandidatePairEvent::CHECK_RESPONSE_RECEIVED;
constexpr IceCandidatePairEvent_IceCandidatePairEventType IceCandidatePairEvent::IceCandidatePairEventType_MIN;
constexpr IceCandidatePairEvent_IceCandidatePairEventType IceCandidatePairEvent::IceCandidatePairEventType_MAX;
constexpr int IceCandidatePairEvent::IceCandidatePairEventType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
bool MediaType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> MediaType_strings[4] = {};

static const char MediaType_names[] =
  "ANY"
  "AUDIO"
  "DATA"
  "VIDEO";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry MediaType_entries[] = {
  { {MediaType_names + 0, 3}, 0 },
  { {MediaType_names + 3, 5}, 1 },
  { {MediaType_names + 8, 4}, 3 },
  { {MediaType_names + 12, 5}, 2 },
};

static const int MediaType_entries_by_number[] = {
  0, // 0 -> ANY
  1, // 1 -> AUDIO
  3, // 2 -> VIDEO
  2, // 3 -> DATA
};

const std::string& MediaType_Name(
    MediaType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          MediaType_entries,
          MediaType_entries_by_number,
          4, MediaType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      MediaType_entries,
      MediaType_entries_by_number,
      4, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     MediaType_strings[idx].get();
}
bool MediaType_Parse(
    const std::string& name, MediaType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      MediaType_entries, 4, name, &int_value);
  if (success) {
    *value = static_cast<MediaType>(int_value);
  }
  return success;
}

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

void EventStream::InitAsDefaultInstance() {
}
class EventStream::_Internal {
 public:
  using HasBits = decltype(std::declval<EventStream>()._has_bits_);
};

EventStream::EventStream()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.EventStream)
}
EventStream::EventStream(const EventStream& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      stream_(from.stream_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.EventStream)
}

void EventStream::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_EventStream_rtc_5fevent_5flog_2eproto.base);
}

EventStream::~EventStream() {
  // @@protoc_insertion_point(destructor:webrtc.rtclog.EventStream)
  SharedDtor();
}

void EventStream::SharedDtor() {
}

void EventStream::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const EventStream& EventStream::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_EventStream_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void EventStream::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.EventStream)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  stream_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* EventStream::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .webrtc.rtclog.Event stream = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_stream(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool EventStream::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.EventStream)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .webrtc.rtclog.Event stream = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_stream()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.EventStream)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.EventStream)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void EventStream::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.rtclog.EventStream)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .webrtc.rtclog.Event stream = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->stream_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
      1,
      this->stream(static_cast<int>(i)),
      output);
  }

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

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .webrtc.rtclog.Event stream = 1;
  {
    unsigned int count = static_cast<unsigned int>(this->stream_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->stream(static_cast<int>(i)));
    }
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void EventStream::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const EventStream*>(
      &from));
}

void EventStream::MergeFrom(const EventStream& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.EventStream)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  stream_.MergeFrom(from.stream_);
}

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

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

void EventStream::InternalSwap(EventStream* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  CastToBase(&stream_)->InternalSwap(CastToBase(&other->stream_));
}

std::string EventStream::GetTypeName() const {
  return "webrtc.rtclog.EventStream";
}


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

void Event::InitAsDefaultInstance() {
}
class Event::_Internal {
 public:
  using HasBits = decltype(std::declval<Event>()._has_bits_);
  static void set_has_timestamp_us(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_type(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::webrtc::rtclog::RtpPacket& rtp_packet(const Event* msg);
  static const ::webrtc::rtclog::RtcpPacket& rtcp_packet(const Event* msg);
  static const ::webrtc::rtclog::AudioPlayoutEvent& audio_playout_event(const Event* msg);
  static const ::webrtc::rtclog::LossBasedBweUpdate& loss_based_bwe_update(const Event* msg);
  static const ::webrtc::rtclog::DelayBasedBweUpdate& delay_based_bwe_update(const Event* msg);
  static const ::webrtc::rtclog::VideoReceiveConfig& video_receiver_config(const Event* msg);
  static const ::webrtc::rtclog::VideoSendConfig& video_sender_config(const Event* msg);
  static const ::webrtc::rtclog::AudioReceiveConfig& audio_receiver_config(const Event* msg);
  static const ::webrtc::rtclog::AudioSendConfig& audio_sender_config(const Event* msg);
  static const ::webrtc::rtclog::AudioNetworkAdaptation& audio_network_adaptation(const Event* msg);
  static const ::webrtc::rtclog::BweProbeCluster& probe_cluster(const Event* msg);
  static const ::webrtc::rtclog::BweProbeResult& probe_result(const Event* msg);
  static const ::webrtc::rtclog::AlrState& alr_state(const Event* msg);
  static const ::webrtc::rtclog::IceCandidatePairConfig& ice_candidate_pair_config(const Event* msg);
  static const ::webrtc::rtclog::IceCandidatePairEvent& ice_candidate_pair_event(const Event* msg);
};

const ::webrtc::rtclog::RtpPacket&
Event::_Internal::rtp_packet(const Event* msg) {
  return *msg->subtype_.rtp_packet_;
}
const ::webrtc::rtclog::RtcpPacket&
Event::_Internal::rtcp_packet(const Event* msg) {
  return *msg->subtype_.rtcp_packet_;
}
const ::webrtc::rtclog::AudioPlayoutEvent&
Event::_Internal::audio_playout_event(const Event* msg) {
  return *msg->subtype_.audio_playout_event_;
}
const ::webrtc::rtclog::LossBasedBweUpdate&
Event::_Internal::loss_based_bwe_update(const Event* msg) {
  return *msg->subtype_.loss_based_bwe_update_;
}
const ::webrtc::rtclog::DelayBasedBweUpdate&
Event::_Internal::delay_based_bwe_update(const Event* msg) {
  return *msg->subtype_.delay_based_bwe_update_;
}
const ::webrtc::rtclog::VideoReceiveConfig&
Event::_Internal::video_receiver_config(const Event* msg) {
  return *msg->subtype_.video_receiver_config_;
}
const ::webrtc::rtclog::VideoSendConfig&
Event::_Internal::video_sender_config(const Event* msg) {
  return *msg->subtype_.video_sender_config_;
}
const ::webrtc::rtclog::AudioReceiveConfig&
Event::_Internal::audio_receiver_config(const Event* msg) {
  return *msg->subtype_.audio_receiver_config_;
}
const ::webrtc::rtclog::AudioSendConfig&
Event::_Internal::audio_sender_config(const Event* msg) {
  return *msg->subtype_.audio_sender_config_;
}
const ::webrtc::rtclog::AudioNetworkAdaptation&
Event::_Internal::audio_network_adaptation(const Event* msg) {
  return *msg->subtype_.audio_network_adaptation_;
}
const ::webrtc::rtclog::BweProbeCluster&
Event::_Internal::probe_cluster(const Event* msg) {
  return *msg->subtype_.probe_cluster_;
}
const ::webrtc::rtclog::BweProbeResult&
Event::_Internal::probe_result(const Event* msg) {
  return *msg->subtype_.probe_result_;
}
const ::webrtc::rtclog::AlrState&
Event::_Internal::alr_state(const Event* msg) {
  return *msg->subtype_.alr_state_;
}
const ::webrtc::rtclog::IceCandidatePairConfig&
Event::_Internal::ice_candidate_pair_config(const Event* msg) {
  return *msg->subtype_.ice_candidate_pair_config_;
}
const ::webrtc::rtclog::IceCandidatePairEvent&
Event::_Internal::ice_candidate_pair_event(const Event* msg) {
  return *msg->subtype_.ice_candidate_pair_event_;
}
void Event::set_allocated_rtp_packet(::webrtc::rtclog::RtpPacket* rtp_packet) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_subtype();
  if (rtp_packet) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      rtp_packet = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, rtp_packet, submessage_arena);
    }
    set_has_rtp_packet();
    subtype_.rtp_packet_ = rtp_packet;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.rtclog.Event.rtp_packet)
}
void Event::set_allocated_rtcp_packet(::webrtc::rtclog::RtcpPacket* rtcp_packet) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_subtype();
  if (rtcp_packet) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      rtcp_packet = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, rtcp_packet, submessage_arena);
    }
    set_has_rtcp_packet();
    subtype_.rtcp_packet_ = rtcp_packet;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.rtclog.Event.rtcp_packet)
}
void Event::set_allocated_audio_playout_event(::webrtc::rtclog::AudioPlayoutEvent* audio_playout_event) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_subtype();
  if (audio_playout_event) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      audio_playout_event = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, audio_playout_event, submessage_arena);
    }
    set_has_audio_playout_event();
    subtype_.audio_playout_event_ = audio_playout_event;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.rtclog.Event.audio_playout_event)
}
void Event::set_allocated_loss_based_bwe_update(::webrtc::rtclog::LossBasedBweUpdate* loss_based_bwe_update) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_subtype();
  if (loss_based_bwe_update) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      loss_based_bwe_update = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, loss_based_bwe_update, submessage_arena);
    }
    set_has_loss_based_bwe_update();
    subtype_.loss_based_bwe_update_ = loss_based_bwe_update;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.rtclog.Event.loss_based_bwe_update)
}
void Event::set_allocated_delay_based_bwe_update(::webrtc::rtclog::DelayBasedBweUpdate* delay_based_bwe_update) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_subtype();
  if (delay_based_bwe_update) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      delay_based_bwe_update = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, delay_based_bwe_update, submessage_arena);
    }
    set_has_delay_based_bwe_update();
    subtype_.delay_based_bwe_update_ = delay_based_bwe_update;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.rtclog.Event.delay_based_bwe_update)
}
void Event::set_allocated_video_receiver_config(::webrtc::rtclog::VideoReceiveConfig* video_receiver_config) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_subtype();
  if (video_receiver_config) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      video_receiver_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, video_receiver_config, submessage_arena);
    }
    set_has_video_receiver_config();
    subtype_.video_receiver_config_ = video_receiver_config;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.rtclog.Event.video_receiver_config)
}
void Event::set_allocated_video_sender_config(::webrtc::rtclog::VideoSendConfig* video_sender_config) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_subtype();
  if (video_sender_config) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      video_sender_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, video_sender_config, submessage_arena);
    }
    set_has_video_sender_config();
    subtype_.video_sender_config_ = video_sender_config;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.rtclog.Event.video_sender_config)
}
void Event::set_allocated_audio_receiver_config(::webrtc::rtclog::AudioReceiveConfig* audio_receiver_config) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_subtype();
  if (audio_receiver_config) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      audio_receiver_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, audio_receiver_config, submessage_arena);
    }
    set_has_audio_receiver_config();
    subtype_.audio_receiver_config_ = audio_receiver_config;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.rtclog.Event.audio_receiver_config)
}
void Event::set_allocated_audio_sender_config(::webrtc::rtclog::AudioSendConfig* audio_sender_config) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_subtype();
  if (audio_sender_config) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      audio_sender_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, audio_sender_config, submessage_arena);
    }
    set_has_audio_sender_config();
    subtype_.audio_sender_config_ = audio_sender_config;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.rtclog.Event.audio_sender_config)
}
void Event::set_allocated_audio_network_adaptation(::webrtc::rtclog::AudioNetworkAdaptation* audio_network_adaptation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_subtype();
  if (audio_network_adaptation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      audio_network_adaptation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, audio_network_adaptation, submessage_arena);
    }
    set_has_audio_network_adaptation();
    subtype_.audio_network_adaptation_ = audio_network_adaptation;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.rtclog.Event.audio_network_adaptation)
}
void Event::set_allocated_probe_cluster(::webrtc::rtclog::BweProbeCluster* probe_cluster) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_subtype();
  if (probe_cluster) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      probe_cluster = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, probe_cluster, submessage_arena);
    }
    set_has_probe_cluster();
    subtype_.probe_cluster_ = probe_cluster;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.rtclog.Event.probe_cluster)
}
void Event::set_allocated_probe_result(::webrtc::rtclog::BweProbeResult* probe_result) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_subtype();
  if (probe_result) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      probe_result = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, probe_result, submessage_arena);
    }
    set_has_probe_result();
    subtype_.probe_result_ = probe_result;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.rtclog.Event.probe_result)
}
void Event::set_allocated_alr_state(::webrtc::rtclog::AlrState* alr_state) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_subtype();
  if (alr_state) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      alr_state = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, alr_state, submessage_arena);
    }
    set_has_alr_state();
    subtype_.alr_state_ = alr_state;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.rtclog.Event.alr_state)
}
void Event::set_allocated_ice_candidate_pair_config(::webrtc::rtclog::IceCandidatePairConfig* ice_candidate_pair_config) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_subtype();
  if (ice_candidate_pair_config) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      ice_candidate_pair_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ice_candidate_pair_config, submessage_arena);
    }
    set_has_ice_candidate_pair_config();
    subtype_.ice_candidate_pair_config_ = ice_candidate_pair_config;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.rtclog.Event.ice_candidate_pair_config)
}
void Event::set_allocated_ice_candidate_pair_event(::webrtc::rtclog::IceCandidatePairEvent* ice_candidate_pair_event) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_subtype();
  if (ice_candidate_pair_event) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      ice_candidate_pair_event = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ice_candidate_pair_event, submessage_arena);
    }
    set_has_ice_candidate_pair_event();
    subtype_.ice_candidate_pair_event_ = ice_candidate_pair_event;
  }
  // @@protoc_insertion_point(field_set_allocated:webrtc.rtclog.Event.ice_candidate_pair_event)
}
Event::Event()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.Event)
}
Event::Event(const Event& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&timestamp_us_, &from.timestamp_us_,
    static_cast<size_t>(reinterpret_cast<char*>(&type_) -
    reinterpret_cast<char*>(&timestamp_us_)) + sizeof(type_));
  clear_has_subtype();
  switch (from.subtype_case()) {
    case kRtpPacket: {
      mutable_rtp_packet()->::webrtc::rtclog::RtpPacket::MergeFrom(from.rtp_packet());
      break;
    }
    case kRtcpPacket: {
      mutable_rtcp_packet()->::webrtc::rtclog::RtcpPacket::MergeFrom(from.rtcp_packet());
      break;
    }
    case kAudioPlayoutEvent: {
      mutable_audio_playout_event()->::webrtc::rtclog::AudioPlayoutEvent::MergeFrom(from.audio_playout_event());
      break;
    }
    case kLossBasedBweUpdate: {
      mutable_loss_based_bwe_update()->::webrtc::rtclog::LossBasedBweUpdate::MergeFrom(from.loss_based_bwe_update());
      break;
    }
    case kDelayBasedBweUpdate: {
      mutable_delay_based_bwe_update()->::webrtc::rtclog::DelayBasedBweUpdate::MergeFrom(from.delay_based_bwe_update());
      break;
    }
    case kVideoReceiverConfig: {
      mutable_video_receiver_config()->::webrtc::rtclog::VideoReceiveConfig::MergeFrom(from.video_receiver_config());
      break;
    }
    case kVideoSenderConfig: {
      mutable_video_sender_config()->::webrtc::rtclog::VideoSendConfig::MergeFrom(from.video_sender_config());
      break;
    }
    case kAudioReceiverConfig: {
      mutable_audio_receiver_config()->::webrtc::rtclog::AudioReceiveConfig::MergeFrom(from.audio_receiver_config());
      break;
    }
    case kAudioSenderConfig: {
      mutable_audio_sender_config()->::webrtc::rtclog::AudioSendConfig::MergeFrom(from.audio_sender_config());
      break;
    }
    case kAudioNetworkAdaptation: {
      mutable_audio_network_adaptation()->::webrtc::rtclog::AudioNetworkAdaptation::MergeFrom(from.audio_network_adaptation());
      break;
    }
    case kProbeCluster: {
      mutable_probe_cluster()->::webrtc::rtclog::BweProbeCluster::MergeFrom(from.probe_cluster());
      break;
    }
    case kProbeResult: {
      mutable_probe_result()->::webrtc::rtclog::BweProbeResult::MergeFrom(from.probe_result());
      break;
    }
    case kAlrState: {
      mutable_alr_state()->::webrtc::rtclog::AlrState::MergeFrom(from.alr_state());
      break;
    }
    case kIceCandidatePairConfig: {
      mutable_ice_candidate_pair_config()->::webrtc::rtclog::IceCandidatePairConfig::MergeFrom(from.ice_candidate_pair_config());
      break;
    }
    case kIceCandidatePairEvent: {
      mutable_ice_candidate_pair_event()->::webrtc::rtclog::IceCandidatePairEvent::MergeFrom(from.ice_candidate_pair_event());
      break;
    }
    case SUBTYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.Event)
}

void Event::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Event_rtc_5fevent_5flog_2eproto.base);
  ::memset(&timestamp_us_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&type_) -
      reinterpret_cast<char*>(&timestamp_us_)) + sizeof(type_));
  clear_has_subtype();
}

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

void Event::SharedDtor() {
  if (has_subtype()) {
    clear_subtype();
  }
}

void Event::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const Event& Event::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Event_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void Event::clear_subtype() {
// @@protoc_insertion_point(one_of_clear_start:webrtc.rtclog.Event)
  switch (subtype_case()) {
    case kRtpPacket: {
      delete subtype_.rtp_packet_;
      break;
    }
    case kRtcpPacket: {
      delete subtype_.rtcp_packet_;
      break;
    }
    case kAudioPlayoutEvent: {
      delete subtype_.audio_playout_event_;
      break;
    }
    case kLossBasedBweUpdate: {
      delete subtype_.loss_based_bwe_update_;
      break;
    }
    case kDelayBasedBweUpdate: {
      delete subtype_.delay_based_bwe_update_;
      break;
    }
    case kVideoReceiverConfig: {
      delete subtype_.video_receiver_config_;
      break;
    }
    case kVideoSenderConfig: {
      delete subtype_.video_sender_config_;
      break;
    }
    case kAudioReceiverConfig: {
      delete subtype_.audio_receiver_config_;
      break;
    }
    case kAudioSenderConfig: {
      delete subtype_.audio_sender_config_;
      break;
    }
    case kAudioNetworkAdaptation: {
      delete subtype_.audio_network_adaptation_;
      break;
    }
    case kProbeCluster: {
      delete subtype_.probe_cluster_;
      break;
    }
    case kProbeResult: {
      delete subtype_.probe_result_;
      break;
    }
    case kAlrState: {
      delete subtype_.alr_state_;
      break;
    }
    case kIceCandidatePairConfig: {
      delete subtype_.ice_candidate_pair_config_;
      break;
    }
    case kIceCandidatePairEvent: {
      delete subtype_.ice_candidate_pair_event_;
      break;
    }
    case SUBTYPE_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = SUBTYPE_NOT_SET;
}


void Event::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.Event)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&timestamp_us_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&type_) -
        reinterpret_cast<char*>(&timestamp_us_)) + sizeof(type_));
  }
  clear_subtype();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Event::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional int64 timestamp_us = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_timestamp_us(&has_bits);
          timestamp_us_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.Event.EventType type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::webrtc::rtclog::Event_EventType_IsValid(val))) {
            set_type(static_cast<::webrtc::rtclog::Event_EventType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.RtpPacket rtp_packet = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(mutable_rtp_packet(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.RtcpPacket rtcp_packet = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(mutable_rtcp_packet(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.AudioPlayoutEvent audio_playout_event = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(mutable_audio_playout_event(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.LossBasedBweUpdate loss_based_bwe_update = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(mutable_loss_based_bwe_update(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.DelayBasedBweUpdate delay_based_bwe_update = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ctx->ParseMessage(mutable_delay_based_bwe_update(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.VideoReceiveConfig video_receiver_config = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr = ctx->ParseMessage(mutable_video_receiver_config(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.VideoSendConfig video_sender_config = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
          ptr = ctx->ParseMessage(mutable_video_sender_config(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.AudioReceiveConfig audio_receiver_config = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
          ptr = ctx->ParseMessage(mutable_audio_receiver_config(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.AudioSendConfig audio_sender_config = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
          ptr = ctx->ParseMessage(mutable_audio_sender_config(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.AudioNetworkAdaptation audio_network_adaptation = 16;
      case 16:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) {
          ptr = ctx->ParseMessage(mutable_audio_network_adaptation(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.BweProbeCluster probe_cluster = 17;
      case 17:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) {
          ptr = ctx->ParseMessage(mutable_probe_cluster(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.BweProbeResult probe_result = 18;
      case 18:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 146)) {
          ptr = ctx->ParseMessage(mutable_probe_result(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.AlrState alr_state = 19;
      case 19:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) {
          ptr = ctx->ParseMessage(mutable_alr_state(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.IceCandidatePairConfig ice_candidate_pair_config = 20;
      case 20:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) {
          ptr = ctx->ParseMessage(mutable_ice_candidate_pair_config(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.IceCandidatePairEvent ice_candidate_pair_event = 21;
      case 21:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) {
          ptr = ctx->ParseMessage(mutable_ice_candidate_pair_event(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Event::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.Event)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(16383u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int64 timestamp_us = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_timestamp_us(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
                 input, &timestamp_us_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.Event.EventType type = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::webrtc::rtclog::Event_EventType_IsValid(value)) {
            set_type(static_cast< ::webrtc::rtclog::Event_EventType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(16u);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.RtpPacket rtp_packet = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_rtp_packet()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.RtcpPacket rtcp_packet = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_rtcp_packet()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.AudioPlayoutEvent audio_playout_event = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_audio_playout_event()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.LossBasedBweUpdate loss_based_bwe_update = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_loss_based_bwe_update()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.DelayBasedBweUpdate delay_based_bwe_update = 7;
      case 7: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (58 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_delay_based_bwe_update()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.VideoReceiveConfig video_receiver_config = 8;
      case 8: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (66 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_video_receiver_config()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.VideoSendConfig video_sender_config = 9;
      case 9: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (74 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_video_sender_config()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.AudioReceiveConfig audio_receiver_config = 10;
      case 10: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (82 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_audio_receiver_config()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.AudioSendConfig audio_sender_config = 11;
      case 11: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (90 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_audio_sender_config()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.AudioNetworkAdaptation audio_network_adaptation = 16;
      case 16: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (130 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_audio_network_adaptation()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.BweProbeCluster probe_cluster = 17;
      case 17: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (138 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_probe_cluster()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.BweProbeResult probe_result = 18;
      case 18: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (146 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_probe_result()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.AlrState alr_state = 19;
      case 19: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (154 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_alr_state()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.IceCandidatePairConfig ice_candidate_pair_config = 20;
      case 20: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (162 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_ice_candidate_pair_config()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.IceCandidatePairEvent ice_candidate_pair_event = 21;
      case 21: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (170 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_ice_candidate_pair_event()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.Event)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.Event)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

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

  cached_has_bits = _has_bits_[0];
  // optional int64 timestamp_us = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(1, this->timestamp_us(), output);
  }

  // optional .webrtc.rtclog.Event.EventType type = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      2, this->type(), output);
  }

  switch (subtype_case()) {
    case kRtpPacket:
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
        3, _Internal::rtp_packet(this), output);
      break;
    case kRtcpPacket:
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
        4, _Internal::rtcp_packet(this), output);
      break;
    case kAudioPlayoutEvent:
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
        5, _Internal::audio_playout_event(this), output);
      break;
    case kLossBasedBweUpdate:
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
        6, _Internal::loss_based_bwe_update(this), output);
      break;
    case kDelayBasedBweUpdate:
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
        7, _Internal::delay_based_bwe_update(this), output);
      break;
    case kVideoReceiverConfig:
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
        8, _Internal::video_receiver_config(this), output);
      break;
    case kVideoSenderConfig:
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
        9, _Internal::video_sender_config(this), output);
      break;
    case kAudioReceiverConfig:
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
        10, _Internal::audio_receiver_config(this), output);
      break;
    case kAudioSenderConfig:
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
        11, _Internal::audio_sender_config(this), output);
      break;
    case kAudioNetworkAdaptation:
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
        16, _Internal::audio_network_adaptation(this), output);
      break;
    case kProbeCluster:
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
        17, _Internal::probe_cluster(this), output);
      break;
    case kProbeResult:
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
        18, _Internal::probe_result(this), output);
      break;
    case kAlrState:
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
        19, _Internal::alr_state(this), output);
      break;
    case kIceCandidatePairConfig:
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
        20, _Internal::ice_candidate_pair_config(this), output);
      break;
    case kIceCandidatePairEvent:
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
        21, _Internal::ice_candidate_pair_event(this), output);
      break;
    default: ;
  }
  output->WriteRaw(_internal_metadata_.unknown_fields().data(),
                   static_cast<int>(_internal_metadata_.unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:webrtc.rtclog.Event)
}

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional int64 timestamp_us = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->timestamp_us());
    }

    // optional .webrtc.rtclog.Event.EventType type = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->type());
    }

  }
  switch (subtype_case()) {
    // optional .webrtc.rtclog.RtpPacket rtp_packet = 3;
    case kRtpPacket: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *subtype_.rtp_packet_);
      break;
    }
    // optional .webrtc.rtclog.RtcpPacket rtcp_packet = 4;
    case kRtcpPacket: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *subtype_.rtcp_packet_);
      break;
    }
    // optional .webrtc.rtclog.AudioPlayoutEvent audio_playout_event = 5;
    case kAudioPlayoutEvent: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *subtype_.audio_playout_event_);
      break;
    }
    // optional .webrtc.rtclog.LossBasedBweUpdate loss_based_bwe_update = 6;
    case kLossBasedBweUpdate: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *subtype_.loss_based_bwe_update_);
      break;
    }
    // optional .webrtc.rtclog.DelayBasedBweUpdate delay_based_bwe_update = 7;
    case kDelayBasedBweUpdate: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *subtype_.delay_based_bwe_update_);
      break;
    }
    // optional .webrtc.rtclog.VideoReceiveConfig video_receiver_config = 8;
    case kVideoReceiverConfig: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *subtype_.video_receiver_config_);
      break;
    }
    // optional .webrtc.rtclog.VideoSendConfig video_sender_config = 9;
    case kVideoSenderConfig: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *subtype_.video_sender_config_);
      break;
    }
    // optional .webrtc.rtclog.AudioReceiveConfig audio_receiver_config = 10;
    case kAudioReceiverConfig: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *subtype_.audio_receiver_config_);
      break;
    }
    // optional .webrtc.rtclog.AudioSendConfig audio_sender_config = 11;
    case kAudioSenderConfig: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *subtype_.audio_sender_config_);
      break;
    }
    // optional .webrtc.rtclog.AudioNetworkAdaptation audio_network_adaptation = 16;
    case kAudioNetworkAdaptation: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *subtype_.audio_network_adaptation_);
      break;
    }
    // optional .webrtc.rtclog.BweProbeCluster probe_cluster = 17;
    case kProbeCluster: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *subtype_.probe_cluster_);
      break;
    }
    // optional .webrtc.rtclog.BweProbeResult probe_result = 18;
    case kProbeResult: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *subtype_.probe_result_);
      break;
    }
    // optional .webrtc.rtclog.AlrState alr_state = 19;
    case kAlrState: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *subtype_.alr_state_);
      break;
    }
    // optional .webrtc.rtclog.IceCandidatePairConfig ice_candidate_pair_config = 20;
    case kIceCandidatePairConfig: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *subtype_.ice_candidate_pair_config_);
      break;
    }
    // optional .webrtc.rtclog.IceCandidatePairEvent ice_candidate_pair_event = 21;
    case kIceCandidatePairEvent: {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *subtype_.ice_candidate_pair_event_);
      break;
    }
    case SUBTYPE_NOT_SET: {
      break;
    }
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Event::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Event*>(
      &from));
}

void Event::MergeFrom(const Event& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.Event)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      timestamp_us_ = from.timestamp_us_;
    }
    if (cached_has_bits & 0x00000002u) {
      type_ = from.type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  switch (from.subtype_case()) {
    case kRtpPacket: {
      mutable_rtp_packet()->::webrtc::rtclog::RtpPacket::MergeFrom(from.rtp_packet());
      break;
    }
    case kRtcpPacket: {
      mutable_rtcp_packet()->::webrtc::rtclog::RtcpPacket::MergeFrom(from.rtcp_packet());
      break;
    }
    case kAudioPlayoutEvent: {
      mutable_audio_playout_event()->::webrtc::rtclog::AudioPlayoutEvent::MergeFrom(from.audio_playout_event());
      break;
    }
    case kLossBasedBweUpdate: {
      mutable_loss_based_bwe_update()->::webrtc::rtclog::LossBasedBweUpdate::MergeFrom(from.loss_based_bwe_update());
      break;
    }
    case kDelayBasedBweUpdate: {
      mutable_delay_based_bwe_update()->::webrtc::rtclog::DelayBasedBweUpdate::MergeFrom(from.delay_based_bwe_update());
      break;
    }
    case kVideoReceiverConfig: {
      mutable_video_receiver_config()->::webrtc::rtclog::VideoReceiveConfig::MergeFrom(from.video_receiver_config());
      break;
    }
    case kVideoSenderConfig: {
      mutable_video_sender_config()->::webrtc::rtclog::VideoSendConfig::MergeFrom(from.video_sender_config());
      break;
    }
    case kAudioReceiverConfig: {
      mutable_audio_receiver_config()->::webrtc::rtclog::AudioReceiveConfig::MergeFrom(from.audio_receiver_config());
      break;
    }
    case kAudioSenderConfig: {
      mutable_audio_sender_config()->::webrtc::rtclog::AudioSendConfig::MergeFrom(from.audio_sender_config());
      break;
    }
    case kAudioNetworkAdaptation: {
      mutable_audio_network_adaptation()->::webrtc::rtclog::AudioNetworkAdaptation::MergeFrom(from.audio_network_adaptation());
      break;
    }
    case kProbeCluster: {
      mutable_probe_cluster()->::webrtc::rtclog::BweProbeCluster::MergeFrom(from.probe_cluster());
      break;
    }
    case kProbeResult: {
      mutable_probe_result()->::webrtc::rtclog::BweProbeResult::MergeFrom(from.probe_result());
      break;
    }
    case kAlrState: {
      mutable_alr_state()->::webrtc::rtclog::AlrState::MergeFrom(from.alr_state());
      break;
    }
    case kIceCandidatePairConfig: {
      mutable_ice_candidate_pair_config()->::webrtc::rtclog::IceCandidatePairConfig::MergeFrom(from.ice_candidate_pair_config());
      break;
    }
    case kIceCandidatePairEvent: {
      mutable_ice_candidate_pair_event()->::webrtc::rtclog::IceCandidatePairEvent::MergeFrom(from.ice_candidate_pair_event());
      break;
    }
    case SUBTYPE_NOT_SET: {
      break;
    }
  }
}

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

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

void Event::InternalSwap(Event* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(timestamp_us_, other->timestamp_us_);
  swap(type_, other->type_);
  swap(subtype_, other->subtype_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

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


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

void RtpPacket::InitAsDefaultInstance() {
}
class RtpPacket::_Internal {
 public:
  using HasBits = decltype(std::declval<RtpPacket>()._has_bits_);
  static void set_has_incoming(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_type(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_packet_length(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_header(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_probe_cluster_id(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
};

RtpPacket::RtpPacket()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.RtpPacket)
}
RtpPacket::RtpPacket(const RtpPacket& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  header_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_header()) {
    header_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.header_);
  }
  ::memcpy(&incoming_, &from.incoming_,
    static_cast<size_t>(reinterpret_cast<char*>(&probe_cluster_id_) -
    reinterpret_cast<char*>(&incoming_)) + sizeof(probe_cluster_id_));
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.RtpPacket)
}

void RtpPacket::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RtpPacket_rtc_5fevent_5flog_2eproto.base);
  header_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&incoming_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&probe_cluster_id_) -
      reinterpret_cast<char*>(&incoming_)) + sizeof(probe_cluster_id_));
}

RtpPacket::~RtpPacket() {
  // @@protoc_insertion_point(destructor:webrtc.rtclog.RtpPacket)
  SharedDtor();
}

void RtpPacket::SharedDtor() {
  header_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void RtpPacket::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const RtpPacket& RtpPacket::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RtpPacket_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void RtpPacket::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.RtpPacket)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    header_.ClearNonDefaultToEmptyNoArena();
  }
  if (cached_has_bits & 0x0000001eu) {
    ::memset(&incoming_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&probe_cluster_id_) -
        reinterpret_cast<char*>(&incoming_)) + sizeof(probe_cluster_id_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* RtpPacket::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bool incoming = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_incoming(&has_bits);
          incoming_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.MediaType type = 2 [deprecated = true];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::webrtc::rtclog::MediaType_IsValid(val))) {
            set_type(static_cast<::webrtc::rtclog::MediaType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional uint32 packet_length = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_packet_length(&has_bits);
          packet_length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes header = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_header(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 probe_cluster_id = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_probe_cluster_id(&has_bits);
          probe_cluster_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool RtpPacket::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.RtpPacket)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool incoming = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_incoming(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &incoming_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.MediaType type = 2 [deprecated = true];
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::webrtc::rtclog::MediaType_IsValid(value)) {
            set_type(static_cast< ::webrtc::rtclog::MediaType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(16u);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 packet_length = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_packet_length(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &packet_length_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes header = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_header()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 probe_cluster_id = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {
          _Internal::set_has_probe_cluster_id(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
                 input, &probe_cluster_id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.RtpPacket)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.RtpPacket)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void RtpPacket::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.rtclog.RtpPacket)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional .webrtc.rtclog.MediaType type = 2 [deprecated = true];
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      2, this->type(), output);
  }

  // optional uint32 packet_length = 3;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(3, this->packet_length(), output);
  }

  // optional bytes header = 4;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      4, this->header(), output);
  }

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

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

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional bytes header = 4;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->header());
    }

    // optional bool incoming = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 1;
    }

    // optional .webrtc.rtclog.MediaType type = 2 [deprecated = true];
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->type());
    }

    // optional uint32 packet_length = 3;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->packet_length());
    }

    // optional int32 probe_cluster_id = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->probe_cluster_id());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RtpPacket::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const RtpPacket*>(
      &from));
}

void RtpPacket::MergeFrom(const RtpPacket& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.RtpPacket)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      header_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.header_);
    }
    if (cached_has_bits & 0x00000002u) {
      incoming_ = from.incoming_;
    }
    if (cached_has_bits & 0x00000004u) {
      type_ = from.type_;
    }
    if (cached_has_bits & 0x00000008u) {
      packet_length_ = from.packet_length_;
    }
    if (cached_has_bits & 0x00000010u) {
      probe_cluster_id_ = from.probe_cluster_id_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void RtpPacket::InternalSwap(RtpPacket* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  header_.Swap(&other->header_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(incoming_, other->incoming_);
  swap(type_, other->type_);
  swap(packet_length_, other->packet_length_);
  swap(probe_cluster_id_, other->probe_cluster_id_);
}

std::string RtpPacket::GetTypeName() const {
  return "webrtc.rtclog.RtpPacket";
}


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

void RtcpPacket::InitAsDefaultInstance() {
}
class RtcpPacket::_Internal {
 public:
  using HasBits = decltype(std::declval<RtcpPacket>()._has_bits_);
  static void set_has_incoming(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_type(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_packet_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

RtcpPacket::RtcpPacket()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.RtcpPacket)
}
RtcpPacket::RtcpPacket(const RtcpPacket& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  packet_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_packet_data()) {
    packet_data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.packet_data_);
  }
  ::memcpy(&incoming_, &from.incoming_,
    static_cast<size_t>(reinterpret_cast<char*>(&type_) -
    reinterpret_cast<char*>(&incoming_)) + sizeof(type_));
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.RtcpPacket)
}

void RtcpPacket::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RtcpPacket_rtc_5fevent_5flog_2eproto.base);
  packet_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&incoming_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&type_) -
      reinterpret_cast<char*>(&incoming_)) + sizeof(type_));
}

RtcpPacket::~RtcpPacket() {
  // @@protoc_insertion_point(destructor:webrtc.rtclog.RtcpPacket)
  SharedDtor();
}

void RtcpPacket::SharedDtor() {
  packet_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void RtcpPacket::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const RtcpPacket& RtcpPacket::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RtcpPacket_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void RtcpPacket::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.RtcpPacket)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    packet_data_.ClearNonDefaultToEmptyNoArena();
  }
  if (cached_has_bits & 0x00000006u) {
    ::memset(&incoming_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&type_) -
        reinterpret_cast<char*>(&incoming_)) + sizeof(type_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* RtcpPacket::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bool incoming = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_incoming(&has_bits);
          incoming_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.MediaType type = 2 [deprecated = true];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::webrtc::rtclog::MediaType_IsValid(val))) {
            set_type(static_cast<::webrtc::rtclog::MediaType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional bytes packet_data = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_packet_data(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool RtcpPacket::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.RtcpPacket)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool incoming = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_incoming(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &incoming_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.MediaType type = 2 [deprecated = true];
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::webrtc::rtclog::MediaType_IsValid(value)) {
            set_type(static_cast< ::webrtc::rtclog::MediaType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(16u);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes packet_data = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_packet_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.RtcpPacket)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.RtcpPacket)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void RtcpPacket::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.rtclog.RtcpPacket)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional .webrtc.rtclog.MediaType type = 2 [deprecated = true];
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      2, this->type(), output);
  }

  // optional bytes packet_data = 3;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
      3, this->packet_data(), output);
  }

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

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional bytes packet_data = 3;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->packet_data());
    }

    // optional bool incoming = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 1;
    }

    // optional .webrtc.rtclog.MediaType type = 2 [deprecated = true];
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->type());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RtcpPacket::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const RtcpPacket*>(
      &from));
}

void RtcpPacket::MergeFrom(const RtcpPacket& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.RtcpPacket)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      packet_data_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.packet_data_);
    }
    if (cached_has_bits & 0x00000002u) {
      incoming_ = from.incoming_;
    }
    if (cached_has_bits & 0x00000004u) {
      type_ = from.type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void RtcpPacket::InternalSwap(RtcpPacket* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  packet_data_.Swap(&other->packet_data_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(incoming_, other->incoming_);
  swap(type_, other->type_);
}

std::string RtcpPacket::GetTypeName() const {
  return "webrtc.rtclog.RtcpPacket";
}


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

void AudioPlayoutEvent::InitAsDefaultInstance() {
}
class AudioPlayoutEvent::_Internal {
 public:
  using HasBits = decltype(std::declval<AudioPlayoutEvent>()._has_bits_);
  static void set_has_local_ssrc(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

AudioPlayoutEvent::AudioPlayoutEvent()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.AudioPlayoutEvent)
}
AudioPlayoutEvent::AudioPlayoutEvent(const AudioPlayoutEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  local_ssrc_ = from.local_ssrc_;
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.AudioPlayoutEvent)
}

void AudioPlayoutEvent::SharedCtor() {
  local_ssrc_ = 0u;
}

AudioPlayoutEvent::~AudioPlayoutEvent() {
  // @@protoc_insertion_point(destructor:webrtc.rtclog.AudioPlayoutEvent)
  SharedDtor();
}

void AudioPlayoutEvent::SharedDtor() {
}

void AudioPlayoutEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const AudioPlayoutEvent& AudioPlayoutEvent::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_AudioPlayoutEvent_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void AudioPlayoutEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.AudioPlayoutEvent)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  local_ssrc_ = 0u;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* AudioPlayoutEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint32 local_ssrc = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_local_ssrc(&has_bits);
          local_ssrc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool AudioPlayoutEvent::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.AudioPlayoutEvent)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 local_ssrc = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_local_ssrc(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &local_ssrc_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.AudioPlayoutEvent)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.AudioPlayoutEvent)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void AudioPlayoutEvent::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.rtclog.AudioPlayoutEvent)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 local_ssrc = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(2, this->local_ssrc(), output);
  }

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

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional uint32 local_ssrc = 2;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->local_ssrc());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void AudioPlayoutEvent::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const AudioPlayoutEvent*>(
      &from));
}

void AudioPlayoutEvent::MergeFrom(const AudioPlayoutEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.AudioPlayoutEvent)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_local_ssrc()) {
    set_local_ssrc(from.local_ssrc());
  }
}

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

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

void AudioPlayoutEvent::InternalSwap(AudioPlayoutEvent* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(local_ssrc_, other->local_ssrc_);
}

std::string AudioPlayoutEvent::GetTypeName() const {
  return "webrtc.rtclog.AudioPlayoutEvent";
}


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

void LossBasedBweUpdate::InitAsDefaultInstance() {
}
class LossBasedBweUpdate::_Internal {
 public:
  using HasBits = decltype(std::declval<LossBasedBweUpdate>()._has_bits_);
  static void set_has_bitrate_bps(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_fraction_loss(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_total_packets(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

LossBasedBweUpdate::LossBasedBweUpdate()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.LossBasedBweUpdate)
}
LossBasedBweUpdate::LossBasedBweUpdate(const LossBasedBweUpdate& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&bitrate_bps_, &from.bitrate_bps_,
    static_cast<size_t>(reinterpret_cast<char*>(&total_packets_) -
    reinterpret_cast<char*>(&bitrate_bps_)) + sizeof(total_packets_));
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.LossBasedBweUpdate)
}

void LossBasedBweUpdate::SharedCtor() {
  ::memset(&bitrate_bps_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&total_packets_) -
      reinterpret_cast<char*>(&bitrate_bps_)) + sizeof(total_packets_));
}

LossBasedBweUpdate::~LossBasedBweUpdate() {
  // @@protoc_insertion_point(destructor:webrtc.rtclog.LossBasedBweUpdate)
  SharedDtor();
}

void LossBasedBweUpdate::SharedDtor() {
}

void LossBasedBweUpdate::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const LossBasedBweUpdate& LossBasedBweUpdate::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_LossBasedBweUpdate_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void LossBasedBweUpdate::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.LossBasedBweUpdate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    ::memset(&bitrate_bps_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&total_packets_) -
        reinterpret_cast<char*>(&bitrate_bps_)) + sizeof(total_packets_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* LossBasedBweUpdate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional int32 bitrate_bps = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_bitrate_bps(&has_bits);
          bitrate_bps_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 fraction_loss = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_fraction_loss(&has_bits);
          fraction_loss_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 total_packets = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_total_packets(&has_bits);
          total_packets_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool LossBasedBweUpdate::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.LossBasedBweUpdate)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 bitrate_bps = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_bitrate_bps(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
                 input, &bitrate_bps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 fraction_loss = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_fraction_loss(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &fraction_loss_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 total_packets = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_total_packets(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
                 input, &total_packets_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.LossBasedBweUpdate)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.LossBasedBweUpdate)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void LossBasedBweUpdate::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.rtclog.LossBasedBweUpdate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional uint32 fraction_loss = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(2, this->fraction_loss(), output);
  }

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

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

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional int32 bitrate_bps = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->bitrate_bps());
    }

    // optional uint32 fraction_loss = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->fraction_loss());
    }

    // optional int32 total_packets = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->total_packets());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void LossBasedBweUpdate::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const LossBasedBweUpdate*>(
      &from));
}

void LossBasedBweUpdate::MergeFrom(const LossBasedBweUpdate& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.LossBasedBweUpdate)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      bitrate_bps_ = from.bitrate_bps_;
    }
    if (cached_has_bits & 0x00000002u) {
      fraction_loss_ = from.fraction_loss_;
    }
    if (cached_has_bits & 0x00000004u) {
      total_packets_ = from.total_packets_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void LossBasedBweUpdate::InternalSwap(LossBasedBweUpdate* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(bitrate_bps_, other->bitrate_bps_);
  swap(fraction_loss_, other->fraction_loss_);
  swap(total_packets_, other->total_packets_);
}

std::string LossBasedBweUpdate::GetTypeName() const {
  return "webrtc.rtclog.LossBasedBweUpdate";
}


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

void DelayBasedBweUpdate::InitAsDefaultInstance() {
}
class DelayBasedBweUpdate::_Internal {
 public:
  using HasBits = decltype(std::declval<DelayBasedBweUpdate>()._has_bits_);
  static void set_has_bitrate_bps(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_detector_state(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

DelayBasedBweUpdate::DelayBasedBweUpdate()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.DelayBasedBweUpdate)
}
DelayBasedBweUpdate::DelayBasedBweUpdate(const DelayBasedBweUpdate& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&bitrate_bps_, &from.bitrate_bps_,
    static_cast<size_t>(reinterpret_cast<char*>(&detector_state_) -
    reinterpret_cast<char*>(&bitrate_bps_)) + sizeof(detector_state_));
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.DelayBasedBweUpdate)
}

void DelayBasedBweUpdate::SharedCtor() {
  ::memset(&bitrate_bps_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&detector_state_) -
      reinterpret_cast<char*>(&bitrate_bps_)) + sizeof(detector_state_));
}

DelayBasedBweUpdate::~DelayBasedBweUpdate() {
  // @@protoc_insertion_point(destructor:webrtc.rtclog.DelayBasedBweUpdate)
  SharedDtor();
}

void DelayBasedBweUpdate::SharedDtor() {
}

void DelayBasedBweUpdate::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const DelayBasedBweUpdate& DelayBasedBweUpdate::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_DelayBasedBweUpdate_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void DelayBasedBweUpdate::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.DelayBasedBweUpdate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&bitrate_bps_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&detector_state_) -
        reinterpret_cast<char*>(&bitrate_bps_)) + sizeof(detector_state_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* DelayBasedBweUpdate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional int32 bitrate_bps = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_bitrate_bps(&has_bits);
          bitrate_bps_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.DelayBasedBweUpdate.DetectorState detector_state = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::webrtc::rtclog::DelayBasedBweUpdate_DetectorState_IsValid(val))) {
            set_detector_state(static_cast<::webrtc::rtclog::DelayBasedBweUpdate_DetectorState>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool DelayBasedBweUpdate::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.DelayBasedBweUpdate)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 bitrate_bps = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_bitrate_bps(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
                 input, &bitrate_bps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.DelayBasedBweUpdate.DetectorState detector_state = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::webrtc::rtclog::DelayBasedBweUpdate_DetectorState_IsValid(value)) {
            set_detector_state(static_cast< ::webrtc::rtclog::DelayBasedBweUpdate_DetectorState >(value));
          } else {
            unknown_fields_stream.WriteVarint32(16u);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.DelayBasedBweUpdate)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.DelayBasedBweUpdate)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void DelayBasedBweUpdate::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.rtclog.DelayBasedBweUpdate)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional .webrtc.rtclog.DelayBasedBweUpdate.DetectorState detector_state = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      2, this->detector_state(), output);
  }

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

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional int32 bitrate_bps = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->bitrate_bps());
    }

    // optional .webrtc.rtclog.DelayBasedBweUpdate.DetectorState detector_state = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->detector_state());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void DelayBasedBweUpdate::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const DelayBasedBweUpdate*>(
      &from));
}

void DelayBasedBweUpdate::MergeFrom(const DelayBasedBweUpdate& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.DelayBasedBweUpdate)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      bitrate_bps_ = from.bitrate_bps_;
    }
    if (cached_has_bits & 0x00000002u) {
      detector_state_ = from.detector_state_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void DelayBasedBweUpdate::InternalSwap(DelayBasedBweUpdate* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(bitrate_bps_, other->bitrate_bps_);
  swap(detector_state_, other->detector_state_);
}

std::string DelayBasedBweUpdate::GetTypeName() const {
  return "webrtc.rtclog.DelayBasedBweUpdate";
}


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

void VideoReceiveConfig::InitAsDefaultInstance() {
}
class VideoReceiveConfig::_Internal {
 public:
  using HasBits = decltype(std::declval<VideoReceiveConfig>()._has_bits_);
  static void set_has_remote_ssrc(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_local_ssrc(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_rtcp_mode(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_remb(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

VideoReceiveConfig::VideoReceiveConfig()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.VideoReceiveConfig)
}
VideoReceiveConfig::VideoReceiveConfig(const VideoReceiveConfig& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      rtx_map_(from.rtx_map_),
      header_extensions_(from.header_extensions_),
      decoders_(from.decoders_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&remote_ssrc_, &from.remote_ssrc_,
    static_cast<size_t>(reinterpret_cast<char*>(&rtcp_mode_) -
    reinterpret_cast<char*>(&remote_ssrc_)) + sizeof(rtcp_mode_));
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.VideoReceiveConfig)
}

void VideoReceiveConfig::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VideoReceiveConfig_rtc_5fevent_5flog_2eproto.base);
  ::memset(&remote_ssrc_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&remb_) -
      reinterpret_cast<char*>(&remote_ssrc_)) + sizeof(remb_));
  rtcp_mode_ = 1;
}

VideoReceiveConfig::~VideoReceiveConfig() {
  // @@protoc_insertion_point(destructor:webrtc.rtclog.VideoReceiveConfig)
  SharedDtor();
}

void VideoReceiveConfig::SharedDtor() {
}

void VideoReceiveConfig::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const VideoReceiveConfig& VideoReceiveConfig::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VideoReceiveConfig_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void VideoReceiveConfig::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.VideoReceiveConfig)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  rtx_map_.Clear();
  header_extensions_.Clear();
  decoders_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    ::memset(&remote_ssrc_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&remb_) -
        reinterpret_cast<char*>(&remote_ssrc_)) + sizeof(remb_));
    rtcp_mode_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* VideoReceiveConfig::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint32 remote_ssrc = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_remote_ssrc(&has_bits);
          remote_ssrc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 local_ssrc = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_local_ssrc(&has_bits);
          local_ssrc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.VideoReceiveConfig.RtcpMode rtcp_mode = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::webrtc::rtclog::VideoReceiveConfig_RtcpMode_IsValid(val))) {
            set_rtcp_mode(static_cast<::webrtc::rtclog::VideoReceiveConfig_RtcpMode>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional bool remb = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_remb(&has_bits);
          remb_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .webrtc.rtclog.RtxMap rtx_map = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_rtx_map(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 42);
        } else goto handle_unusual;
        continue;
      // repeated .webrtc.rtclog.RtpHeaderExtension header_extensions = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_header_extensions(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 50);
        } else goto handle_unusual;
        continue;
      // repeated .webrtc.rtclog.DecoderConfig decoders = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_decoders(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 58);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool VideoReceiveConfig::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.VideoReceiveConfig)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 remote_ssrc = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_remote_ssrc(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &remote_ssrc_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 local_ssrc = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_local_ssrc(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &local_ssrc_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.VideoReceiveConfig.RtcpMode rtcp_mode = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::webrtc::rtclog::VideoReceiveConfig_RtcpMode_IsValid(value)) {
            set_rtcp_mode(static_cast< ::webrtc::rtclog::VideoReceiveConfig_RtcpMode >(value));
          } else {
            unknown_fields_stream.WriteVarint32(24u);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool remb = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
          _Internal::set_has_remb(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &remb_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .webrtc.rtclog.RtxMap rtx_map = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_rtx_map()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .webrtc.rtclog.RtpHeaderExtension header_extensions = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_header_extensions()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .webrtc.rtclog.DecoderConfig decoders = 7;
      case 7: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (58 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_decoders()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.VideoReceiveConfig)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.VideoReceiveConfig)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void VideoReceiveConfig::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.rtclog.VideoReceiveConfig)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 remote_ssrc = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(1, this->remote_ssrc(), output);
  }

  // optional uint32 local_ssrc = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(2, this->local_ssrc(), output);
  }

  // optional .webrtc.rtclog.VideoReceiveConfig.RtcpMode rtcp_mode = 3;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      3, this->rtcp_mode(), output);
  }

  // optional bool remb = 4;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(4, this->remb(), output);
  }

  // repeated .webrtc.rtclog.RtxMap rtx_map = 5;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->rtx_map_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
      5,
      this->rtx_map(static_cast<int>(i)),
      output);
  }

  // repeated .webrtc.rtclog.RtpHeaderExtension header_extensions = 6;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->header_extensions_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
      6,
      this->header_extensions(static_cast<int>(i)),
      output);
  }

  // repeated .webrtc.rtclog.DecoderConfig decoders = 7;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->decoders_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
      7,
      this->decoders(static_cast<int>(i)),
      output);
  }

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

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .webrtc.rtclog.RtxMap rtx_map = 5;
  {
    unsigned int count = static_cast<unsigned int>(this->rtx_map_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->rtx_map(static_cast<int>(i)));
    }
  }

  // repeated .webrtc.rtclog.RtpHeaderExtension header_extensions = 6;
  {
    unsigned int count = static_cast<unsigned int>(this->header_extensions_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->header_extensions(static_cast<int>(i)));
    }
  }

  // repeated .webrtc.rtclog.DecoderConfig decoders = 7;
  {
    unsigned int count = static_cast<unsigned int>(this->decoders_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->decoders(static_cast<int>(i)));
    }
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional uint32 remote_ssrc = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->remote_ssrc());
    }

    // optional uint32 local_ssrc = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->local_ssrc());
    }

    // optional bool remb = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 1;
    }

    // optional .webrtc.rtclog.VideoReceiveConfig.RtcpMode rtcp_mode = 3;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->rtcp_mode());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void VideoReceiveConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const VideoReceiveConfig*>(
      &from));
}

void VideoReceiveConfig::MergeFrom(const VideoReceiveConfig& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.VideoReceiveConfig)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  rtx_map_.MergeFrom(from.rtx_map_);
  header_extensions_.MergeFrom(from.header_extensions_);
  decoders_.MergeFrom(from.decoders_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      remote_ssrc_ = from.remote_ssrc_;
    }
    if (cached_has_bits & 0x00000002u) {
      local_ssrc_ = from.local_ssrc_;
    }
    if (cached_has_bits & 0x00000004u) {
      remb_ = from.remb_;
    }
    if (cached_has_bits & 0x00000008u) {
      rtcp_mode_ = from.rtcp_mode_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void VideoReceiveConfig::InternalSwap(VideoReceiveConfig* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  CastToBase(&rtx_map_)->InternalSwap(CastToBase(&other->rtx_map_));
  CastToBase(&header_extensions_)->InternalSwap(CastToBase(&other->header_extensions_));
  CastToBase(&decoders_)->InternalSwap(CastToBase(&other->decoders_));
  swap(remote_ssrc_, other->remote_ssrc_);
  swap(local_ssrc_, other->local_ssrc_);
  swap(remb_, other->remb_);
  swap(rtcp_mode_, other->rtcp_mode_);
}

std::string VideoReceiveConfig::GetTypeName() const {
  return "webrtc.rtclog.VideoReceiveConfig";
}


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

void DecoderConfig::InitAsDefaultInstance() {
}
class DecoderConfig::_Internal {
 public:
  using HasBits = decltype(std::declval<DecoderConfig>()._has_bits_);
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_payload_type(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

DecoderConfig::DecoderConfig()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.DecoderConfig)
}
DecoderConfig::DecoderConfig(const DecoderConfig& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_name()) {
    name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  payload_type_ = from.payload_type_;
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.DecoderConfig)
}

void DecoderConfig::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DecoderConfig_rtc_5fevent_5flog_2eproto.base);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  payload_type_ = 0;
}

DecoderConfig::~DecoderConfig() {
  // @@protoc_insertion_point(destructor:webrtc.rtclog.DecoderConfig)
  SharedDtor();
}

void DecoderConfig::SharedDtor() {
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void DecoderConfig::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const DecoderConfig& DecoderConfig::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_DecoderConfig_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void DecoderConfig::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.DecoderConfig)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    name_.ClearNonDefaultToEmptyNoArena();
  }
  payload_type_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* DecoderConfig::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_name(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 payload_type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_payload_type(&has_bits);
          payload_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool DecoderConfig::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.DecoderConfig)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string name = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 payload_type = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_payload_type(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
                 input, &payload_type_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.DecoderConfig)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.DecoderConfig)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void DecoderConfig::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.rtclog.DecoderConfig)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

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

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

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional string name = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->name());
    }

    // optional int32 payload_type = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->payload_type());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void DecoderConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const DecoderConfig*>(
      &from));
}

void DecoderConfig::MergeFrom(const DecoderConfig& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.DecoderConfig)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
    }
    if (cached_has_bits & 0x00000002u) {
      payload_type_ = from.payload_type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void DecoderConfig::InternalSwap(DecoderConfig* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(payload_type_, other->payload_type_);
}

std::string DecoderConfig::GetTypeName() const {
  return "webrtc.rtclog.DecoderConfig";
}


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

void RtpHeaderExtension::InitAsDefaultInstance() {
}
class RtpHeaderExtension::_Internal {
 public:
  using HasBits = decltype(std::declval<RtpHeaderExtension>()._has_bits_);
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

RtpHeaderExtension::RtpHeaderExtension()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.RtpHeaderExtension)
}
RtpHeaderExtension::RtpHeaderExtension(const RtpHeaderExtension& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_name()) {
    name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  id_ = from.id_;
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.RtpHeaderExtension)
}

void RtpHeaderExtension::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RtpHeaderExtension_rtc_5fevent_5flog_2eproto.base);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  id_ = 0;
}

RtpHeaderExtension::~RtpHeaderExtension() {
  // @@protoc_insertion_point(destructor:webrtc.rtclog.RtpHeaderExtension)
  SharedDtor();
}

void RtpHeaderExtension::SharedDtor() {
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void RtpHeaderExtension::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const RtpHeaderExtension& RtpHeaderExtension::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RtpHeaderExtension_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void RtpHeaderExtension::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.RtpHeaderExtension)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    name_.ClearNonDefaultToEmptyNoArena();
  }
  id_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* RtpHeaderExtension::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_name(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 id = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_id(&has_bits);
          id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool RtpHeaderExtension::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.RtpHeaderExtension)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string name = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 id = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_id(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
                 input, &id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.RtpHeaderExtension)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.RtpHeaderExtension)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void RtpHeaderExtension::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.rtclog.RtpHeaderExtension)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

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

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

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional string name = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->name());
    }

    // optional int32 id = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->id());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RtpHeaderExtension::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const RtpHeaderExtension*>(
      &from));
}

void RtpHeaderExtension::MergeFrom(const RtpHeaderExtension& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.RtpHeaderExtension)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
    }
    if (cached_has_bits & 0x00000002u) {
      id_ = from.id_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void RtpHeaderExtension::InternalSwap(RtpHeaderExtension* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(id_, other->id_);
}

std::string RtpHeaderExtension::GetTypeName() const {
  return "webrtc.rtclog.RtpHeaderExtension";
}


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

void RtxConfig::InitAsDefaultInstance() {
}
class RtxConfig::_Internal {
 public:
  using HasBits = decltype(std::declval<RtxConfig>()._has_bits_);
  static void set_has_rtx_ssrc(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_rtx_payload_type(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

RtxConfig::RtxConfig()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.RtxConfig)
}
RtxConfig::RtxConfig(const RtxConfig& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&rtx_ssrc_, &from.rtx_ssrc_,
    static_cast<size_t>(reinterpret_cast<char*>(&rtx_payload_type_) -
    reinterpret_cast<char*>(&rtx_ssrc_)) + sizeof(rtx_payload_type_));
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.RtxConfig)
}

void RtxConfig::SharedCtor() {
  ::memset(&rtx_ssrc_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&rtx_payload_type_) -
      reinterpret_cast<char*>(&rtx_ssrc_)) + sizeof(rtx_payload_type_));
}

RtxConfig::~RtxConfig() {
  // @@protoc_insertion_point(destructor:webrtc.rtclog.RtxConfig)
  SharedDtor();
}

void RtxConfig::SharedDtor() {
}

void RtxConfig::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const RtxConfig& RtxConfig::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RtxConfig_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void RtxConfig::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.RtxConfig)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&rtx_ssrc_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&rtx_payload_type_) -
        reinterpret_cast<char*>(&rtx_ssrc_)) + sizeof(rtx_payload_type_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* RtxConfig::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint32 rtx_ssrc = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_rtx_ssrc(&has_bits);
          rtx_ssrc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 rtx_payload_type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_rtx_payload_type(&has_bits);
          rtx_payload_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool RtxConfig::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.RtxConfig)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 rtx_ssrc = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_rtx_ssrc(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &rtx_ssrc_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 rtx_payload_type = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_rtx_payload_type(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
                 input, &rtx_payload_type_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.RtxConfig)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.RtxConfig)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void RtxConfig::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.rtclog.RtxConfig)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 rtx_ssrc = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(1, this->rtx_ssrc(), output);
  }

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

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

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional uint32 rtx_ssrc = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->rtx_ssrc());
    }

    // optional int32 rtx_payload_type = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->rtx_payload_type());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RtxConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const RtxConfig*>(
      &from));
}

void RtxConfig::MergeFrom(const RtxConfig& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.RtxConfig)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      rtx_ssrc_ = from.rtx_ssrc_;
    }
    if (cached_has_bits & 0x00000002u) {
      rtx_payload_type_ = from.rtx_payload_type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void RtxConfig::InternalSwap(RtxConfig* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(rtx_ssrc_, other->rtx_ssrc_);
  swap(rtx_payload_type_, other->rtx_payload_type_);
}

std::string RtxConfig::GetTypeName() const {
  return "webrtc.rtclog.RtxConfig";
}


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

void RtxMap::InitAsDefaultInstance() {
  ::webrtc::rtclog::_RtxMap_default_instance_._instance.get_mutable()->config_ = const_cast< ::webrtc::rtclog::RtxConfig*>(
      ::webrtc::rtclog::RtxConfig::internal_default_instance());
}
class RtxMap::_Internal {
 public:
  using HasBits = decltype(std::declval<RtxMap>()._has_bits_);
  static void set_has_payload_type(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::webrtc::rtclog::RtxConfig& config(const RtxMap* msg);
  static void set_has_config(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::webrtc::rtclog::RtxConfig&
RtxMap::_Internal::config(const RtxMap* msg) {
  return *msg->config_;
}
RtxMap::RtxMap()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.RtxMap)
}
RtxMap::RtxMap(const RtxMap& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_config()) {
    config_ = new ::webrtc::rtclog::RtxConfig(*from.config_);
  } else {
    config_ = nullptr;
  }
  payload_type_ = from.payload_type_;
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.RtxMap)
}

void RtxMap::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RtxMap_rtc_5fevent_5flog_2eproto.base);
  ::memset(&config_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&payload_type_) -
      reinterpret_cast<char*>(&config_)) + sizeof(payload_type_));
}

RtxMap::~RtxMap() {
  // @@protoc_insertion_point(destructor:webrtc.rtclog.RtxMap)
  SharedDtor();
}

void RtxMap::SharedDtor() {
  if (this != internal_default_instance()) delete config_;
}

void RtxMap::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const RtxMap& RtxMap::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RtxMap_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void RtxMap::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.RtxMap)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(config_ != nullptr);
    config_->Clear();
  }
  payload_type_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* RtxMap::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional int32 payload_type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_payload_type(&has_bits);
          payload_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.RtxConfig config = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(mutable_config(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool RtxMap::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.RtxMap)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 payload_type = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_payload_type(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
                 input, &payload_type_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.RtxConfig config = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_config()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.RtxMap)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.RtxMap)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void RtxMap::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.rtclog.RtxMap)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 payload_type = 1;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32(1, this->payload_type(), output);
  }

  // optional .webrtc.rtclog.RtxConfig config = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
      2, _Internal::config(this), output);
  }

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

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional .webrtc.rtclog.RtxConfig config = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *config_);
    }

    // optional int32 payload_type = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->payload_type());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RtxMap::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const RtxMap*>(
      &from));
}

void RtxMap::MergeFrom(const RtxMap& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.RtxMap)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_config()->::webrtc::rtclog::RtxConfig::MergeFrom(from.config());
    }
    if (cached_has_bits & 0x00000002u) {
      payload_type_ = from.payload_type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void RtxMap::InternalSwap(RtxMap* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(config_, other->config_);
  swap(payload_type_, other->payload_type_);
}

std::string RtxMap::GetTypeName() const {
  return "webrtc.rtclog.RtxMap";
}


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

void VideoSendConfig::InitAsDefaultInstance() {
  ::webrtc::rtclog::_VideoSendConfig_default_instance_._instance.get_mutable()->encoder_ = const_cast< ::webrtc::rtclog::EncoderConfig*>(
      ::webrtc::rtclog::EncoderConfig::internal_default_instance());
}
class VideoSendConfig::_Internal {
 public:
  using HasBits = decltype(std::declval<VideoSendConfig>()._has_bits_);
  static void set_has_rtx_payload_type(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::webrtc::rtclog::EncoderConfig& encoder(const VideoSendConfig* msg);
  static void set_has_encoder(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::webrtc::rtclog::EncoderConfig&
VideoSendConfig::_Internal::encoder(const VideoSendConfig* msg) {
  return *msg->encoder_;
}
VideoSendConfig::VideoSendConfig()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.VideoSendConfig)
}
VideoSendConfig::VideoSendConfig(const VideoSendConfig& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      ssrcs_(from.ssrcs_),
      header_extensions_(from.header_extensions_),
      rtx_ssrcs_(from.rtx_ssrcs_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_encoder()) {
    encoder_ = new ::webrtc::rtclog::EncoderConfig(*from.encoder_);
  } else {
    encoder_ = nullptr;
  }
  rtx_payload_type_ = from.rtx_payload_type_;
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.VideoSendConfig)
}

void VideoSendConfig::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VideoSendConfig_rtc_5fevent_5flog_2eproto.base);
  ::memset(&encoder_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&rtx_payload_type_) -
      reinterpret_cast<char*>(&encoder_)) + sizeof(rtx_payload_type_));
}

VideoSendConfig::~VideoSendConfig() {
  // @@protoc_insertion_point(destructor:webrtc.rtclog.VideoSendConfig)
  SharedDtor();
}

void VideoSendConfig::SharedDtor() {
  if (this != internal_default_instance()) delete encoder_;
}

void VideoSendConfig::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const VideoSendConfig& VideoSendConfig::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VideoSendConfig_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void VideoSendConfig::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.VideoSendConfig)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ssrcs_.Clear();
  header_extensions_.Clear();
  rtx_ssrcs_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(encoder_ != nullptr);
    encoder_->Clear();
  }
  rtx_payload_type_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* VideoSendConfig::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated uint32 ssrcs = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ptr -= 1;
          do {
            ptr += 1;
            add_ssrcs(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 8);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(mutable_ssrcs(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .webrtc.rtclog.RtpHeaderExtension header_extensions = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_header_extensions(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18);
        } else goto handle_unusual;
        continue;
      // repeated uint32 rtx_ssrcs = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ptr -= 1;
          do {
            ptr += 1;
            add_rtx_ssrcs(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 24);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(mutable_rtx_ssrcs(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 rtx_payload_type = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_rtx_payload_type(&has_bits);
          rtx_payload_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.EncoderConfig encoder = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(mutable_encoder(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool VideoSendConfig::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.VideoSendConfig)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated uint32 ssrcs = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 1, 8u, input, this->mutable_ssrcs())));
        } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_ssrcs())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .webrtc.rtclog.RtpHeaderExtension header_extensions = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_header_extensions()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated uint32 rtx_ssrcs = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 1, 24u, input, this->mutable_rtx_ssrcs())));
        } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, this->mutable_rtx_ssrcs())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 rtx_payload_type = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
          _Internal::set_has_rtx_payload_type(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
                 input, &rtx_payload_type_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.EncoderConfig encoder = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_encoder()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.VideoSendConfig)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.VideoSendConfig)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void VideoSendConfig::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.rtclog.VideoSendConfig)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated uint32 ssrcs = 1;
  for (int i = 0, n = this->ssrcs_size(); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(
      1, this->ssrcs(i), output);
  }

  // repeated .webrtc.rtclog.RtpHeaderExtension header_extensions = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->header_extensions_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
      2,
      this->header_extensions(static_cast<int>(i)),
      output);
  }

  // repeated uint32 rtx_ssrcs = 3;
  for (int i = 0, n = this->rtx_ssrcs_size(); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(
      3, this->rtx_ssrcs(i), output);
  }

  cached_has_bits = _has_bits_[0];
  // optional int32 rtx_payload_type = 4;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32(4, this->rtx_payload_type(), output);
  }

  // optional .webrtc.rtclog.EncoderConfig encoder = 5;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
      5, _Internal::encoder(this), output);
  }

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

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated uint32 ssrcs = 1;
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      UInt32Size(this->ssrcs_);
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->ssrcs_size());
    total_size += data_size;
  }

  // repeated .webrtc.rtclog.RtpHeaderExtension header_extensions = 2;
  {
    unsigned int count = static_cast<unsigned int>(this->header_extensions_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->header_extensions(static_cast<int>(i)));
    }
  }

  // repeated uint32 rtx_ssrcs = 3;
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      UInt32Size(this->rtx_ssrcs_);
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->rtx_ssrcs_size());
    total_size += data_size;
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional .webrtc.rtclog.EncoderConfig encoder = 5;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *encoder_);
    }

    // optional int32 rtx_payload_type = 4;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->rtx_payload_type());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void VideoSendConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const VideoSendConfig*>(
      &from));
}

void VideoSendConfig::MergeFrom(const VideoSendConfig& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.VideoSendConfig)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  ssrcs_.MergeFrom(from.ssrcs_);
  header_extensions_.MergeFrom(from.header_extensions_);
  rtx_ssrcs_.MergeFrom(from.rtx_ssrcs_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_encoder()->::webrtc::rtclog::EncoderConfig::MergeFrom(from.encoder());
    }
    if (cached_has_bits & 0x00000002u) {
      rtx_payload_type_ = from.rtx_payload_type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void VideoSendConfig::InternalSwap(VideoSendConfig* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ssrcs_.InternalSwap(&other->ssrcs_);
  CastToBase(&header_extensions_)->InternalSwap(CastToBase(&other->header_extensions_));
  rtx_ssrcs_.InternalSwap(&other->rtx_ssrcs_);
  swap(encoder_, other->encoder_);
  swap(rtx_payload_type_, other->rtx_payload_type_);
}

std::string VideoSendConfig::GetTypeName() const {
  return "webrtc.rtclog.VideoSendConfig";
}


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

void EncoderConfig::InitAsDefaultInstance() {
}
class EncoderConfig::_Internal {
 public:
  using HasBits = decltype(std::declval<EncoderConfig>()._has_bits_);
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_payload_type(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

EncoderConfig::EncoderConfig()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.EncoderConfig)
}
EncoderConfig::EncoderConfig(const EncoderConfig& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_name()) {
    name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  payload_type_ = from.payload_type_;
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.EncoderConfig)
}

void EncoderConfig::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_EncoderConfig_rtc_5fevent_5flog_2eproto.base);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  payload_type_ = 0;
}

EncoderConfig::~EncoderConfig() {
  // @@protoc_insertion_point(destructor:webrtc.rtclog.EncoderConfig)
  SharedDtor();
}

void EncoderConfig::SharedDtor() {
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void EncoderConfig::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const EncoderConfig& EncoderConfig::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_EncoderConfig_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void EncoderConfig::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.EncoderConfig)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    name_.ClearNonDefaultToEmptyNoArena();
  }
  payload_type_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* EncoderConfig::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_name(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 payload_type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_payload_type(&has_bits);
          payload_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool EncoderConfig::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.EncoderConfig)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string name = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 payload_type = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_payload_type(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
                 input, &payload_type_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.EncoderConfig)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.EncoderConfig)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void EncoderConfig::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.rtclog.EncoderConfig)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

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

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

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional string name = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->name());
    }

    // optional int32 payload_type = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->payload_type());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void EncoderConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const EncoderConfig*>(
      &from));
}

void EncoderConfig::MergeFrom(const EncoderConfig& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.EncoderConfig)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
    }
    if (cached_has_bits & 0x00000002u) {
      payload_type_ = from.payload_type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void EncoderConfig::InternalSwap(EncoderConfig* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(payload_type_, other->payload_type_);
}

std::string EncoderConfig::GetTypeName() const {
  return "webrtc.rtclog.EncoderConfig";
}


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

void AudioReceiveConfig::InitAsDefaultInstance() {
}
class AudioReceiveConfig::_Internal {
 public:
  using HasBits = decltype(std::declval<AudioReceiveConfig>()._has_bits_);
  static void set_has_remote_ssrc(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_local_ssrc(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

AudioReceiveConfig::AudioReceiveConfig()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.AudioReceiveConfig)
}
AudioReceiveConfig::AudioReceiveConfig(const AudioReceiveConfig& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      header_extensions_(from.header_extensions_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&remote_ssrc_, &from.remote_ssrc_,
    static_cast<size_t>(reinterpret_cast<char*>(&local_ssrc_) -
    reinterpret_cast<char*>(&remote_ssrc_)) + sizeof(local_ssrc_));
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.AudioReceiveConfig)
}

void AudioReceiveConfig::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_AudioReceiveConfig_rtc_5fevent_5flog_2eproto.base);
  ::memset(&remote_ssrc_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&local_ssrc_) -
      reinterpret_cast<char*>(&remote_ssrc_)) + sizeof(local_ssrc_));
}

AudioReceiveConfig::~AudioReceiveConfig() {
  // @@protoc_insertion_point(destructor:webrtc.rtclog.AudioReceiveConfig)
  SharedDtor();
}

void AudioReceiveConfig::SharedDtor() {
}

void AudioReceiveConfig::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const AudioReceiveConfig& AudioReceiveConfig::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_AudioReceiveConfig_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void AudioReceiveConfig::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.AudioReceiveConfig)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  header_extensions_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&remote_ssrc_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&local_ssrc_) -
        reinterpret_cast<char*>(&remote_ssrc_)) + sizeof(local_ssrc_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* AudioReceiveConfig::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint32 remote_ssrc = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_remote_ssrc(&has_bits);
          remote_ssrc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 local_ssrc = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_local_ssrc(&has_bits);
          local_ssrc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .webrtc.rtclog.RtpHeaderExtension header_extensions = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_header_extensions(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 26);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool AudioReceiveConfig::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.AudioReceiveConfig)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 remote_ssrc = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_remote_ssrc(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &remote_ssrc_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 local_ssrc = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_local_ssrc(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &local_ssrc_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .webrtc.rtclog.RtpHeaderExtension header_extensions = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_header_extensions()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.AudioReceiveConfig)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.AudioReceiveConfig)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void AudioReceiveConfig::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.rtclog.AudioReceiveConfig)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 remote_ssrc = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(1, this->remote_ssrc(), output);
  }

  // optional uint32 local_ssrc = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(2, this->local_ssrc(), output);
  }

  // repeated .webrtc.rtclog.RtpHeaderExtension header_extensions = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->header_extensions_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
      3,
      this->header_extensions(static_cast<int>(i)),
      output);
  }

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

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .webrtc.rtclog.RtpHeaderExtension header_extensions = 3;
  {
    unsigned int count = static_cast<unsigned int>(this->header_extensions_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->header_extensions(static_cast<int>(i)));
    }
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional uint32 remote_ssrc = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->remote_ssrc());
    }

    // optional uint32 local_ssrc = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->local_ssrc());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void AudioReceiveConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const AudioReceiveConfig*>(
      &from));
}

void AudioReceiveConfig::MergeFrom(const AudioReceiveConfig& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.AudioReceiveConfig)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  header_extensions_.MergeFrom(from.header_extensions_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      remote_ssrc_ = from.remote_ssrc_;
    }
    if (cached_has_bits & 0x00000002u) {
      local_ssrc_ = from.local_ssrc_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void AudioReceiveConfig::InternalSwap(AudioReceiveConfig* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  CastToBase(&header_extensions_)->InternalSwap(CastToBase(&other->header_extensions_));
  swap(remote_ssrc_, other->remote_ssrc_);
  swap(local_ssrc_, other->local_ssrc_);
}

std::string AudioReceiveConfig::GetTypeName() const {
  return "webrtc.rtclog.AudioReceiveConfig";
}


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

void AudioSendConfig::InitAsDefaultInstance() {
}
class AudioSendConfig::_Internal {
 public:
  using HasBits = decltype(std::declval<AudioSendConfig>()._has_bits_);
  static void set_has_ssrc(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

AudioSendConfig::AudioSendConfig()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.AudioSendConfig)
}
AudioSendConfig::AudioSendConfig(const AudioSendConfig& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      header_extensions_(from.header_extensions_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ssrc_ = from.ssrc_;
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.AudioSendConfig)
}

void AudioSendConfig::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_AudioSendConfig_rtc_5fevent_5flog_2eproto.base);
  ssrc_ = 0u;
}

AudioSendConfig::~AudioSendConfig() {
  // @@protoc_insertion_point(destructor:webrtc.rtclog.AudioSendConfig)
  SharedDtor();
}

void AudioSendConfig::SharedDtor() {
}

void AudioSendConfig::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const AudioSendConfig& AudioSendConfig::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_AudioSendConfig_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void AudioSendConfig::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.AudioSendConfig)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  header_extensions_.Clear();
  ssrc_ = 0u;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* AudioSendConfig::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional uint32 ssrc = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_ssrc(&has_bits);
          ssrc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .webrtc.rtclog.RtpHeaderExtension header_extensions = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_header_extensions(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool AudioSendConfig::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.AudioSendConfig)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 ssrc = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_ssrc(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &ssrc_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .webrtc.rtclog.RtpHeaderExtension header_extensions = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_header_extensions()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.AudioSendConfig)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.AudioSendConfig)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void AudioSendConfig::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.rtclog.AudioSendConfig)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 ssrc = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(1, this->ssrc(), output);
  }

  // repeated .webrtc.rtclog.RtpHeaderExtension header_extensions = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->header_extensions_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
      2,
      this->header_extensions(static_cast<int>(i)),
      output);
  }

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

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .webrtc.rtclog.RtpHeaderExtension header_extensions = 2;
  {
    unsigned int count = static_cast<unsigned int>(this->header_extensions_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->header_extensions(static_cast<int>(i)));
    }
  }

  // optional uint32 ssrc = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->ssrc());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void AudioSendConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const AudioSendConfig*>(
      &from));
}

void AudioSendConfig::MergeFrom(const AudioSendConfig& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.AudioSendConfig)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  header_extensions_.MergeFrom(from.header_extensions_);
  if (from.has_ssrc()) {
    set_ssrc(from.ssrc());
  }
}

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

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

void AudioSendConfig::InternalSwap(AudioSendConfig* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  CastToBase(&header_extensions_)->InternalSwap(CastToBase(&other->header_extensions_));
  swap(ssrc_, other->ssrc_);
}

std::string AudioSendConfig::GetTypeName() const {
  return "webrtc.rtclog.AudioSendConfig";
}


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

void AudioNetworkAdaptation::InitAsDefaultInstance() {
}
class AudioNetworkAdaptation::_Internal {
 public:
  using HasBits = decltype(std::declval<AudioNetworkAdaptation>()._has_bits_);
  static void set_has_bitrate_bps(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_frame_length_ms(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_uplink_packet_loss_fraction(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_enable_fec(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_enable_dtx(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_num_channels(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
};

AudioNetworkAdaptation::AudioNetworkAdaptation()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.AudioNetworkAdaptation)
}
AudioNetworkAdaptation::AudioNetworkAdaptation(const AudioNetworkAdaptation& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&bitrate_bps_, &from.bitrate_bps_,
    static_cast<size_t>(reinterpret_cast<char*>(&num_channels_) -
    reinterpret_cast<char*>(&bitrate_bps_)) + sizeof(num_channels_));
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.AudioNetworkAdaptation)
}

void AudioNetworkAdaptation::SharedCtor() {
  ::memset(&bitrate_bps_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&num_channels_) -
      reinterpret_cast<char*>(&bitrate_bps_)) + sizeof(num_channels_));
}

AudioNetworkAdaptation::~AudioNetworkAdaptation() {
  // @@protoc_insertion_point(destructor:webrtc.rtclog.AudioNetworkAdaptation)
  SharedDtor();
}

void AudioNetworkAdaptation::SharedDtor() {
}

void AudioNetworkAdaptation::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const AudioNetworkAdaptation& AudioNetworkAdaptation::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_AudioNetworkAdaptation_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void AudioNetworkAdaptation::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.AudioNetworkAdaptation)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    ::memset(&bitrate_bps_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&num_channels_) -
        reinterpret_cast<char*>(&bitrate_bps_)) + sizeof(num_channels_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* AudioNetworkAdaptation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional int32 bitrate_bps = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_bitrate_bps(&has_bits);
          bitrate_bps_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 frame_length_ms = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_frame_length_ms(&has_bits);
          frame_length_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional float uplink_packet_loss_fraction = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
          _Internal::set_has_uplink_packet_loss_fraction(&has_bits);
          uplink_packet_loss_fraction_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // optional bool enable_fec = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_enable_fec(&has_bits);
          enable_fec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool enable_dtx = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_enable_dtx(&has_bits);
          enable_dtx_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 num_channels = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_num_channels(&has_bits);
          num_channels_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool AudioNetworkAdaptation::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.AudioNetworkAdaptation)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 bitrate_bps = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_bitrate_bps(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
                 input, &bitrate_bps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 frame_length_ms = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_frame_length_ms(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
                 input, &frame_length_ms_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional float uplink_packet_loss_fraction = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (29 & 0xFF)) {
          _Internal::set_has_uplink_packet_loss_fraction(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &uplink_packet_loss_fraction_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool enable_fec = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
          _Internal::set_has_enable_fec(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &enable_fec_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool enable_dtx = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {
          _Internal::set_has_enable_dtx(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &enable_dtx_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 num_channels = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) {
          _Internal::set_has_num_channels(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &num_channels_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.AudioNetworkAdaptation)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.AudioNetworkAdaptation)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void AudioNetworkAdaptation::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.rtclog.AudioNetworkAdaptation)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  // optional float uplink_packet_loss_fraction = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(3, this->uplink_packet_loss_fraction(), output);
  }

  // optional bool enable_fec = 4;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(4, this->enable_fec(), output);
  }

  // optional bool enable_dtx = 5;
  if (cached_has_bits & 0x00000010u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(5, this->enable_dtx(), output);
  }

  // optional uint32 num_channels = 6;
  if (cached_has_bits & 0x00000020u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(6, this->num_channels(), output);
  }

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

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    // optional int32 bitrate_bps = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->bitrate_bps());
    }

    // optional int32 frame_length_ms = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->frame_length_ms());
    }

    // optional float uplink_packet_loss_fraction = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 4;
    }

    // optional bool enable_fec = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 1;
    }

    // optional bool enable_dtx = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 1;
    }

    // optional uint32 num_channels = 6;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->num_channels());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void AudioNetworkAdaptation::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const AudioNetworkAdaptation*>(
      &from));
}

void AudioNetworkAdaptation::MergeFrom(const AudioNetworkAdaptation& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.AudioNetworkAdaptation)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      bitrate_bps_ = from.bitrate_bps_;
    }
    if (cached_has_bits & 0x00000002u) {
      frame_length_ms_ = from.frame_length_ms_;
    }
    if (cached_has_bits & 0x00000004u) {
      uplink_packet_loss_fraction_ = from.uplink_packet_loss_fraction_;
    }
    if (cached_has_bits & 0x00000008u) {
      enable_fec_ = from.enable_fec_;
    }
    if (cached_has_bits & 0x00000010u) {
      enable_dtx_ = from.enable_dtx_;
    }
    if (cached_has_bits & 0x00000020u) {
      num_channels_ = from.num_channels_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void AudioNetworkAdaptation::InternalSwap(AudioNetworkAdaptation* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(bitrate_bps_, other->bitrate_bps_);
  swap(frame_length_ms_, other->frame_length_ms_);
  swap(uplink_packet_loss_fraction_, other->uplink_packet_loss_fraction_);
  swap(enable_fec_, other->enable_fec_);
  swap(enable_dtx_, other->enable_dtx_);
  swap(num_channels_, other->num_channels_);
}

std::string AudioNetworkAdaptation::GetTypeName() const {
  return "webrtc.rtclog.AudioNetworkAdaptation";
}


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

void BweProbeCluster::InitAsDefaultInstance() {
}
class BweProbeCluster::_Internal {
 public:
  using HasBits = decltype(std::declval<BweProbeCluster>()._has_bits_);
  static void set_has_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_bitrate_bps(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_min_packets(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_min_bytes(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

BweProbeCluster::BweProbeCluster()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.BweProbeCluster)
}
BweProbeCluster::BweProbeCluster(const BweProbeCluster& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&id_, &from.id_,
    static_cast<size_t>(reinterpret_cast<char*>(&min_bytes_) -
    reinterpret_cast<char*>(&id_)) + sizeof(min_bytes_));
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.BweProbeCluster)
}

void BweProbeCluster::SharedCtor() {
  ::memset(&id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&min_bytes_) -
      reinterpret_cast<char*>(&id_)) + sizeof(min_bytes_));
}

BweProbeCluster::~BweProbeCluster() {
  // @@protoc_insertion_point(destructor:webrtc.rtclog.BweProbeCluster)
  SharedDtor();
}

void BweProbeCluster::SharedDtor() {
}

void BweProbeCluster::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const BweProbeCluster& BweProbeCluster::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BweProbeCluster_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void BweProbeCluster::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.BweProbeCluster)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    ::memset(&id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&min_bytes_) -
        reinterpret_cast<char*>(&id_)) + sizeof(min_bytes_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* BweProbeCluster::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional int32 id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_id(&has_bits);
          id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 bitrate_bps = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_bitrate_bps(&has_bits);
          bitrate_bps_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 min_packets = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_min_packets(&has_bits);
          min_packets_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint32 min_bytes = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_min_bytes(&has_bits);
          min_bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool BweProbeCluster::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.BweProbeCluster)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 id = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_id(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
                 input, &id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 bitrate_bps = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_bitrate_bps(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
                 input, &bitrate_bps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 min_packets = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_min_packets(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &min_packets_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 min_bytes = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
          _Internal::set_has_min_bytes(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &min_bytes_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.BweProbeCluster)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.BweProbeCluster)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void BweProbeCluster::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.rtclog.BweProbeCluster)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  // optional uint32 min_packets = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(3, this->min_packets(), output);
  }

  // optional uint32 min_bytes = 4;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(4, this->min_bytes(), output);
  }

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

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional int32 id = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->id());
    }

    // optional int32 bitrate_bps = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->bitrate_bps());
    }

    // optional uint32 min_packets = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->min_packets());
    }

    // optional uint32 min_bytes = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->min_bytes());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void BweProbeCluster::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const BweProbeCluster*>(
      &from));
}

void BweProbeCluster::MergeFrom(const BweProbeCluster& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.BweProbeCluster)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      id_ = from.id_;
    }
    if (cached_has_bits & 0x00000002u) {
      bitrate_bps_ = from.bitrate_bps_;
    }
    if (cached_has_bits & 0x00000004u) {
      min_packets_ = from.min_packets_;
    }
    if (cached_has_bits & 0x00000008u) {
      min_bytes_ = from.min_bytes_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void BweProbeCluster::InternalSwap(BweProbeCluster* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(id_, other->id_);
  swap(bitrate_bps_, other->bitrate_bps_);
  swap(min_packets_, other->min_packets_);
  swap(min_bytes_, other->min_bytes_);
}

std::string BweProbeCluster::GetTypeName() const {
  return "webrtc.rtclog.BweProbeCluster";
}


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

void BweProbeResult::InitAsDefaultInstance() {
}
class BweProbeResult::_Internal {
 public:
  using HasBits = decltype(std::declval<BweProbeResult>()._has_bits_);
  static void set_has_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_result(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_bitrate_bps(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

BweProbeResult::BweProbeResult()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.BweProbeResult)
}
BweProbeResult::BweProbeResult(const BweProbeResult& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&id_, &from.id_,
    static_cast<size_t>(reinterpret_cast<char*>(&bitrate_bps_) -
    reinterpret_cast<char*>(&id_)) + sizeof(bitrate_bps_));
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.BweProbeResult)
}

void BweProbeResult::SharedCtor() {
  ::memset(&id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&bitrate_bps_) -
      reinterpret_cast<char*>(&id_)) + sizeof(bitrate_bps_));
}

BweProbeResult::~BweProbeResult() {
  // @@protoc_insertion_point(destructor:webrtc.rtclog.BweProbeResult)
  SharedDtor();
}

void BweProbeResult::SharedDtor() {
}

void BweProbeResult::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const BweProbeResult& BweProbeResult::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BweProbeResult_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void BweProbeResult::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.BweProbeResult)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    ::memset(&id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&bitrate_bps_) -
        reinterpret_cast<char*>(&id_)) + sizeof(bitrate_bps_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* BweProbeResult::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional int32 id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_id(&has_bits);
          id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.BweProbeResult.ResultType result = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::webrtc::rtclog::BweProbeResult_ResultType_IsValid(val))) {
            set_result(static_cast<::webrtc::rtclog::BweProbeResult_ResultType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional int32 bitrate_bps = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_bitrate_bps(&has_bits);
          bitrate_bps_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool BweProbeResult::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.BweProbeResult)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 id = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_id(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
                 input, &id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.BweProbeResult.ResultType result = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::webrtc::rtclog::BweProbeResult_ResultType_IsValid(value)) {
            set_result(static_cast< ::webrtc::rtclog::BweProbeResult_ResultType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(16u);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 bitrate_bps = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          _Internal::set_has_bitrate_bps(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
                 input, &bitrate_bps_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.BweProbeResult)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.BweProbeResult)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void BweProbeResult::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.rtclog.BweProbeResult)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional .webrtc.rtclog.BweProbeResult.ResultType result = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      2, this->result(), output);
  }

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

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

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional int32 id = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->id());
    }

    // optional .webrtc.rtclog.BweProbeResult.ResultType result = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->result());
    }

    // optional int32 bitrate_bps = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->bitrate_bps());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void BweProbeResult::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const BweProbeResult*>(
      &from));
}

void BweProbeResult::MergeFrom(const BweProbeResult& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.BweProbeResult)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      id_ = from.id_;
    }
    if (cached_has_bits & 0x00000002u) {
      result_ = from.result_;
    }
    if (cached_has_bits & 0x00000004u) {
      bitrate_bps_ = from.bitrate_bps_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void BweProbeResult::InternalSwap(BweProbeResult* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(id_, other->id_);
  swap(result_, other->result_);
  swap(bitrate_bps_, other->bitrate_bps_);
}

std::string BweProbeResult::GetTypeName() const {
  return "webrtc.rtclog.BweProbeResult";
}


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

void AlrState::InitAsDefaultInstance() {
}
class AlrState::_Internal {
 public:
  using HasBits = decltype(std::declval<AlrState>()._has_bits_);
  static void set_has_in_alr(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

AlrState::AlrState()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.AlrState)
}
AlrState::AlrState(const AlrState& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  in_alr_ = from.in_alr_;
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.AlrState)
}

void AlrState::SharedCtor() {
  in_alr_ = false;
}

AlrState::~AlrState() {
  // @@protoc_insertion_point(destructor:webrtc.rtclog.AlrState)
  SharedDtor();
}

void AlrState::SharedDtor() {
}

void AlrState::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const AlrState& AlrState::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_AlrState_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void AlrState::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.AlrState)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  in_alr_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* AlrState::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional bool in_alr = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_in_alr(&has_bits);
          in_alr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool AlrState::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.AlrState)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool in_alr = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          _Internal::set_has_in_alr(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &in_alr_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.AlrState)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.AlrState)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void AlrState::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.rtclog.AlrState)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool in_alr = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(1, this->in_alr(), output);
  }

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

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional bool in_alr = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 + 1;
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void AlrState::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const AlrState*>(
      &from));
}

void AlrState::MergeFrom(const AlrState& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.AlrState)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_in_alr()) {
    set_in_alr(from.in_alr());
  }
}

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

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

void AlrState::InternalSwap(AlrState* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(in_alr_, other->in_alr_);
}

std::string AlrState::GetTypeName() const {
  return "webrtc.rtclog.AlrState";
}


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

void IceCandidatePairConfig::InitAsDefaultInstance() {
}
class IceCandidatePairConfig::_Internal {
 public:
  using HasBits = decltype(std::declval<IceCandidatePairConfig>()._has_bits_);
  static void set_has_config_type(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_candidate_pair_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_local_candidate_type(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_local_relay_protocol(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_local_network_type(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_local_address_family(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_remote_candidate_type(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_remote_address_family(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_candidate_pair_protocol(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
};

IceCandidatePairConfig::IceCandidatePairConfig()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.IceCandidatePairConfig)
}
IceCandidatePairConfig::IceCandidatePairConfig(const IceCandidatePairConfig& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&config_type_, &from.config_type_,
    static_cast<size_t>(reinterpret_cast<char*>(&candidate_pair_protocol_) -
    reinterpret_cast<char*>(&config_type_)) + sizeof(candidate_pair_protocol_));
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.IceCandidatePairConfig)
}

void IceCandidatePairConfig::SharedCtor() {
  ::memset(&config_type_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&candidate_pair_protocol_) -
      reinterpret_cast<char*>(&config_type_)) + sizeof(candidate_pair_protocol_));
}

IceCandidatePairConfig::~IceCandidatePairConfig() {
  // @@protoc_insertion_point(destructor:webrtc.rtclog.IceCandidatePairConfig)
  SharedDtor();
}

void IceCandidatePairConfig::SharedDtor() {
}

void IceCandidatePairConfig::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const IceCandidatePairConfig& IceCandidatePairConfig::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_IceCandidatePairConfig_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void IceCandidatePairConfig::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.IceCandidatePairConfig)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    ::memset(&config_type_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&remote_address_family_) -
        reinterpret_cast<char*>(&config_type_)) + sizeof(remote_address_family_));
  }
  candidate_pair_protocol_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* IceCandidatePairConfig::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .webrtc.rtclog.IceCandidatePairConfig.IceCandidatePairConfigType config_type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::webrtc::rtclog::IceCandidatePairConfig_IceCandidatePairConfigType_IsValid(val))) {
            set_config_type(static_cast<::webrtc::rtclog::IceCandidatePairConfig_IceCandidatePairConfigType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional uint32 candidate_pair_id = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_candidate_pair_id(&has_bits);
          candidate_pair_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.IceCandidatePairConfig.IceCandidateType local_candidate_type = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::webrtc::rtclog::IceCandidatePairConfig_IceCandidateType_IsValid(val))) {
            set_local_candidate_type(static_cast<::webrtc::rtclog::IceCandidatePairConfig_IceCandidateType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.IceCandidatePairConfig.Protocol local_relay_protocol = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::webrtc::rtclog::IceCandidatePairConfig_Protocol_IsValid(val))) {
            set_local_relay_protocol(static_cast<::webrtc::rtclog::IceCandidatePairConfig_Protocol>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.IceCandidatePairConfig.NetworkType local_network_type = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::webrtc::rtclog::IceCandidatePairConfig_NetworkType_IsValid(val))) {
            set_local_network_type(static_cast<::webrtc::rtclog::IceCandidatePairConfig_NetworkType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.IceCandidatePairConfig.AddressFamily local_address_family = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::webrtc::rtclog::IceCandidatePairConfig_AddressFamily_IsValid(val))) {
            set_local_address_family(static_cast<::webrtc::rtclog::IceCandidatePairConfig_AddressFamily>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.IceCandidatePairConfig.IceCandidateType remote_candidate_type = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::webrtc::rtclog::IceCandidatePairConfig_IceCandidateType_IsValid(val))) {
            set_remote_candidate_type(static_cast<::webrtc::rtclog::IceCandidatePairConfig_IceCandidateType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(7, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.IceCandidatePairConfig.AddressFamily remote_address_family = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::webrtc::rtclog::IceCandidatePairConfig_AddressFamily_IsValid(val))) {
            set_remote_address_family(static_cast<::webrtc::rtclog::IceCandidatePairConfig_AddressFamily>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(8, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .webrtc.rtclog.IceCandidatePairConfig.Protocol candidate_pair_protocol = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::webrtc::rtclog::IceCandidatePairConfig_Protocol_IsValid(val))) {
            set_candidate_pair_protocol(static_cast<::webrtc::rtclog::IceCandidatePairConfig_Protocol>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(9, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool IceCandidatePairConfig::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.IceCandidatePairConfig)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .webrtc.rtclog.IceCandidatePairConfig.IceCandidatePairConfigType config_type = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::webrtc::rtclog::IceCandidatePairConfig_IceCandidatePairConfigType_IsValid(value)) {
            set_config_type(static_cast< ::webrtc::rtclog::IceCandidatePairConfig_IceCandidatePairConfigType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(8u);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 candidate_pair_id = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_candidate_pair_id(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &candidate_pair_id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.IceCandidatePairConfig.IceCandidateType local_candidate_type = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::webrtc::rtclog::IceCandidatePairConfig_IceCandidateType_IsValid(value)) {
            set_local_candidate_type(static_cast< ::webrtc::rtclog::IceCandidatePairConfig_IceCandidateType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(24u);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.IceCandidatePairConfig.Protocol local_relay_protocol = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::webrtc::rtclog::IceCandidatePairConfig_Protocol_IsValid(value)) {
            set_local_relay_protocol(static_cast< ::webrtc::rtclog::IceCandidatePairConfig_Protocol >(value));
          } else {
            unknown_fields_stream.WriteVarint32(32u);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.IceCandidatePairConfig.NetworkType local_network_type = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::webrtc::rtclog::IceCandidatePairConfig_NetworkType_IsValid(value)) {
            set_local_network_type(static_cast< ::webrtc::rtclog::IceCandidatePairConfig_NetworkType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(40u);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.IceCandidatePairConfig.AddressFamily local_address_family = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::webrtc::rtclog::IceCandidatePairConfig_AddressFamily_IsValid(value)) {
            set_local_address_family(static_cast< ::webrtc::rtclog::IceCandidatePairConfig_AddressFamily >(value));
          } else {
            unknown_fields_stream.WriteVarint32(48u);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.IceCandidatePairConfig.IceCandidateType remote_candidate_type = 7;
      case 7: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (56 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::webrtc::rtclog::IceCandidatePairConfig_IceCandidateType_IsValid(value)) {
            set_remote_candidate_type(static_cast< ::webrtc::rtclog::IceCandidatePairConfig_IceCandidateType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(56u);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.IceCandidatePairConfig.AddressFamily remote_address_family = 8;
      case 8: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (64 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::webrtc::rtclog::IceCandidatePairConfig_AddressFamily_IsValid(value)) {
            set_remote_address_family(static_cast< ::webrtc::rtclog::IceCandidatePairConfig_AddressFamily >(value));
          } else {
            unknown_fields_stream.WriteVarint32(64u);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .webrtc.rtclog.IceCandidatePairConfig.Protocol candidate_pair_protocol = 9;
      case 9: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (72 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::webrtc::rtclog::IceCandidatePairConfig_Protocol_IsValid(value)) {
            set_candidate_pair_protocol(static_cast< ::webrtc::rtclog::IceCandidatePairConfig_Protocol >(value));
          } else {
            unknown_fields_stream.WriteVarint32(72u);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.IceCandidatePairConfig)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.IceCandidatePairConfig)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void IceCandidatePairConfig::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.rtclog.IceCandidatePairConfig)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .webrtc.rtclog.IceCandidatePairConfig.IceCandidatePairConfigType config_type = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      1, this->config_type(), output);
  }

  // optional uint32 candidate_pair_id = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(2, this->candidate_pair_id(), output);
  }

  // optional .webrtc.rtclog.IceCandidatePairConfig.IceCandidateType local_candidate_type = 3;
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      3, this->local_candidate_type(), output);
  }

  // optional .webrtc.rtclog.IceCandidatePairConfig.Protocol local_relay_protocol = 4;
  if (cached_has_bits & 0x00000008u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      4, this->local_relay_protocol(), output);
  }

  // optional .webrtc.rtclog.IceCandidatePairConfig.NetworkType local_network_type = 5;
  if (cached_has_bits & 0x00000010u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      5, this->local_network_type(), output);
  }

  // optional .webrtc.rtclog.IceCandidatePairConfig.AddressFamily local_address_family = 6;
  if (cached_has_bits & 0x00000020u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      6, this->local_address_family(), output);
  }

  // optional .webrtc.rtclog.IceCandidatePairConfig.IceCandidateType remote_candidate_type = 7;
  if (cached_has_bits & 0x00000040u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      7, this->remote_candidate_type(), output);
  }

  // optional .webrtc.rtclog.IceCandidatePairConfig.AddressFamily remote_address_family = 8;
  if (cached_has_bits & 0x00000080u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      8, this->remote_address_family(), output);
  }

  // optional .webrtc.rtclog.IceCandidatePairConfig.Protocol candidate_pair_protocol = 9;
  if (cached_has_bits & 0x00000100u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      9, this->candidate_pair_protocol(), output);
  }

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

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional .webrtc.rtclog.IceCandidatePairConfig.IceCandidatePairConfigType config_type = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->config_type());
    }

    // optional uint32 candidate_pair_id = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->candidate_pair_id());
    }

    // optional .webrtc.rtclog.IceCandidatePairConfig.IceCandidateType local_candidate_type = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->local_candidate_type());
    }

    // optional .webrtc.rtclog.IceCandidatePairConfig.Protocol local_relay_protocol = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->local_relay_protocol());
    }

    // optional .webrtc.rtclog.IceCandidatePairConfig.NetworkType local_network_type = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->local_network_type());
    }

    // optional .webrtc.rtclog.IceCandidatePairConfig.AddressFamily local_address_family = 6;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->local_address_family());
    }

    // optional .webrtc.rtclog.IceCandidatePairConfig.IceCandidateType remote_candidate_type = 7;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->remote_candidate_type());
    }

    // optional .webrtc.rtclog.IceCandidatePairConfig.AddressFamily remote_address_family = 8;
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->remote_address_family());
    }

  }
  // optional .webrtc.rtclog.IceCandidatePairConfig.Protocol candidate_pair_protocol = 9;
  if (cached_has_bits & 0x00000100u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->candidate_pair_protocol());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void IceCandidatePairConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const IceCandidatePairConfig*>(
      &from));
}

void IceCandidatePairConfig::MergeFrom(const IceCandidatePairConfig& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.IceCandidatePairConfig)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      config_type_ = from.config_type_;
    }
    if (cached_has_bits & 0x00000002u) {
      candidate_pair_id_ = from.candidate_pair_id_;
    }
    if (cached_has_bits & 0x00000004u) {
      local_candidate_type_ = from.local_candidate_type_;
    }
    if (cached_has_bits & 0x00000008u) {
      local_relay_protocol_ = from.local_relay_protocol_;
    }
    if (cached_has_bits & 0x00000010u) {
      local_network_type_ = from.local_network_type_;
    }
    if (cached_has_bits & 0x00000020u) {
      local_address_family_ = from.local_address_family_;
    }
    if (cached_has_bits & 0x00000040u) {
      remote_candidate_type_ = from.remote_candidate_type_;
    }
    if (cached_has_bits & 0x00000080u) {
      remote_address_family_ = from.remote_address_family_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00000100u) {
    set_candidate_pair_protocol(from.candidate_pair_protocol());
  }
}

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

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

void IceCandidatePairConfig::InternalSwap(IceCandidatePairConfig* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(config_type_, other->config_type_);
  swap(candidate_pair_id_, other->candidate_pair_id_);
  swap(local_candidate_type_, other->local_candidate_type_);
  swap(local_relay_protocol_, other->local_relay_protocol_);
  swap(local_network_type_, other->local_network_type_);
  swap(local_address_family_, other->local_address_family_);
  swap(remote_candidate_type_, other->remote_candidate_type_);
  swap(remote_address_family_, other->remote_address_family_);
  swap(candidate_pair_protocol_, other->candidate_pair_protocol_);
}

std::string IceCandidatePairConfig::GetTypeName() const {
  return "webrtc.rtclog.IceCandidatePairConfig";
}


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

void IceCandidatePairEvent::InitAsDefaultInstance() {
}
class IceCandidatePairEvent::_Internal {
 public:
  using HasBits = decltype(std::declval<IceCandidatePairEvent>()._has_bits_);
  static void set_has_event_type(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_candidate_pair_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

IceCandidatePairEvent::IceCandidatePairEvent()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:webrtc.rtclog.IceCandidatePairEvent)
}
IceCandidatePairEvent::IceCandidatePairEvent(const IceCandidatePairEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&event_type_, &from.event_type_,
    static_cast<size_t>(reinterpret_cast<char*>(&candidate_pair_id_) -
    reinterpret_cast<char*>(&event_type_)) + sizeof(candidate_pair_id_));
  // @@protoc_insertion_point(copy_constructor:webrtc.rtclog.IceCandidatePairEvent)
}

void IceCandidatePairEvent::SharedCtor() {
  ::memset(&event_type_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&candidate_pair_id_) -
      reinterpret_cast<char*>(&event_type_)) + sizeof(candidate_pair_id_));
}

IceCandidatePairEvent::~IceCandidatePairEvent() {
  // @@protoc_insertion_point(destructor:webrtc.rtclog.IceCandidatePairEvent)
  SharedDtor();
}

void IceCandidatePairEvent::SharedDtor() {
}

void IceCandidatePairEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const IceCandidatePairEvent& IceCandidatePairEvent::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_IceCandidatePairEvent_rtc_5fevent_5flog_2eproto.base);
  return *internal_default_instance();
}


void IceCandidatePairEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:webrtc.rtclog.IceCandidatePairEvent)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&event_type_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&candidate_pair_id_) -
        reinterpret_cast<char*>(&event_type_)) + sizeof(candidate_pair_id_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* IceCandidatePairEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional .webrtc.rtclog.IceCandidatePairEvent.IceCandidatePairEventType event_type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::webrtc::rtclog::IceCandidatePairEvent_IceCandidatePairEventType_IsValid(val))) {
            set_event_type(static_cast<::webrtc::rtclog::IceCandidatePairEvent_IceCandidatePairEventType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional uint32 candidate_pair_id = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_candidate_pair_id(&has_bits);
          candidate_pair_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool IceCandidatePairEvent::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:webrtc.rtclog.IceCandidatePairEvent)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .webrtc.rtclog.IceCandidatePairEvent.IceCandidatePairEventType event_type = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::webrtc::rtclog::IceCandidatePairEvent_IceCandidatePairEventType_IsValid(value)) {
            set_event_type(static_cast< ::webrtc::rtclog::IceCandidatePairEvent_IceCandidatePairEventType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(8u);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 candidate_pair_id = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_candidate_pair_id(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &candidate_pair_id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:webrtc.rtclog.IceCandidatePairEvent)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:webrtc.rtclog.IceCandidatePairEvent)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void IceCandidatePairEvent::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:webrtc.rtclog.IceCandidatePairEvent)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .webrtc.rtclog.IceCandidatePairEvent.IceCandidatePairEventType event_type = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      1, this->event_type(), output);
  }

  // optional uint32 candidate_pair_id = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(2, this->candidate_pair_id(), output);
  }

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

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

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional .webrtc.rtclog.IceCandidatePairEvent.IceCandidatePairEventType event_type = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->event_type());
    }

    // optional uint32 candidate_pair_id = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
          this->candidate_pair_id());
    }

  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void IceCandidatePairEvent::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const IceCandidatePairEvent*>(
      &from));
}

void IceCandidatePairEvent::MergeFrom(const IceCandidatePairEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:webrtc.rtclog.IceCandidatePairEvent)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      event_type_ = from.event_type_;
    }
    if (cached_has_bits & 0x00000002u) {
      candidate_pair_id_ = from.candidate_pair_id_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

void IceCandidatePairEvent::InternalSwap(IceCandidatePairEvent* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(event_type_, other->event_type_);
  swap(candidate_pair_id_, other->candidate_pair_id_);
}

std::string IceCandidatePairEvent::GetTypeName() const {
  return "webrtc.rtclog.IceCandidatePairEvent";
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace rtclog
}  // namespace webrtc
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::EventStream* Arena::CreateMaybeMessage< ::webrtc::rtclog::EventStream >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::EventStream >(arena);
}
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::Event* Arena::CreateMaybeMessage< ::webrtc::rtclog::Event >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::Event >(arena);
}
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::RtpPacket* Arena::CreateMaybeMessage< ::webrtc::rtclog::RtpPacket >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::RtpPacket >(arena);
}
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::RtcpPacket* Arena::CreateMaybeMessage< ::webrtc::rtclog::RtcpPacket >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::RtcpPacket >(arena);
}
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::AudioPlayoutEvent* Arena::CreateMaybeMessage< ::webrtc::rtclog::AudioPlayoutEvent >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::AudioPlayoutEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::LossBasedBweUpdate* Arena::CreateMaybeMessage< ::webrtc::rtclog::LossBasedBweUpdate >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::LossBasedBweUpdate >(arena);
}
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::DelayBasedBweUpdate* Arena::CreateMaybeMessage< ::webrtc::rtclog::DelayBasedBweUpdate >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::DelayBasedBweUpdate >(arena);
}
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::VideoReceiveConfig* Arena::CreateMaybeMessage< ::webrtc::rtclog::VideoReceiveConfig >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::VideoReceiveConfig >(arena);
}
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::DecoderConfig* Arena::CreateMaybeMessage< ::webrtc::rtclog::DecoderConfig >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::DecoderConfig >(arena);
}
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::RtpHeaderExtension* Arena::CreateMaybeMessage< ::webrtc::rtclog::RtpHeaderExtension >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::RtpHeaderExtension >(arena);
}
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::RtxConfig* Arena::CreateMaybeMessage< ::webrtc::rtclog::RtxConfig >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::RtxConfig >(arena);
}
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::RtxMap* Arena::CreateMaybeMessage< ::webrtc::rtclog::RtxMap >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::RtxMap >(arena);
}
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::VideoSendConfig* Arena::CreateMaybeMessage< ::webrtc::rtclog::VideoSendConfig >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::VideoSendConfig >(arena);
}
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::EncoderConfig* Arena::CreateMaybeMessage< ::webrtc::rtclog::EncoderConfig >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::EncoderConfig >(arena);
}
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::AudioReceiveConfig* Arena::CreateMaybeMessage< ::webrtc::rtclog::AudioReceiveConfig >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::AudioReceiveConfig >(arena);
}
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::AudioSendConfig* Arena::CreateMaybeMessage< ::webrtc::rtclog::AudioSendConfig >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::AudioSendConfig >(arena);
}
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::AudioNetworkAdaptation* Arena::CreateMaybeMessage< ::webrtc::rtclog::AudioNetworkAdaptation >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::AudioNetworkAdaptation >(arena);
}
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::BweProbeCluster* Arena::CreateMaybeMessage< ::webrtc::rtclog::BweProbeCluster >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::BweProbeCluster >(arena);
}
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::BweProbeResult* Arena::CreateMaybeMessage< ::webrtc::rtclog::BweProbeResult >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::BweProbeResult >(arena);
}
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::AlrState* Arena::CreateMaybeMessage< ::webrtc::rtclog::AlrState >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::AlrState >(arena);
}
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::IceCandidatePairConfig* Arena::CreateMaybeMessage< ::webrtc::rtclog::IceCandidatePairConfig >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::IceCandidatePairConfig >(arena);
}
template<> PROTOBUF_NOINLINE ::webrtc::rtclog::IceCandidatePairEvent* Arena::CreateMaybeMessage< ::webrtc::rtclog::IceCandidatePairEvent >(Arena* arena) {
  return Arena::CreateInternal< ::webrtc::rtclog::IceCandidatePairEvent >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
