Hide RtcEvent members behind accessors
Bug: webrtc:8111
Change-Id: I3d350a6e159330aed7362162006860ac86ed7c32
Reviewed-on: https://webrtc-review.googlesource.com/c/109881
Commit-Queue: Elad Alon <eladalon@webrtc.org>
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#25590}diff --git a/logging/BUILD.gn b/logging/BUILD.gn
index cc19ec6..b48394d 100644
--- a/logging/BUILD.gn
+++ b/logging/BUILD.gn
@@ -88,6 +88,7 @@
":rtc_event_log_api",
":rtc_stream_config",
"../modules/audio_coding:audio_network_adaptor_config",
+ "../rtc_base:checks",
"../rtc_base:ptr_util",
"//third_party/abseil-cpp/absl/memory",
]
@@ -131,6 +132,7 @@
":rtc_event_log_api",
"../api:array_view",
"../modules/rtp_rtcp:rtp_rtcp_format",
+ "../rtc_base:checks",
"../rtc_base:ptr_util",
"../rtc_base:rtc_base_approved",
"//third_party/abseil-cpp/absl/memory",
@@ -148,6 +150,7 @@
deps = [
":rtc_event_log_api",
":rtc_stream_config",
+ "../rtc_base:checks",
"../rtc_base:ptr_util",
"//third_party/abseil-cpp/absl/memory",
]
diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.cc b/logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.cc
index 618c861..c60b211 100644
--- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.cc
+++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.cc
@@ -356,37 +356,37 @@
std::string RtcEventLogEncoderLegacy::EncodeAlrState(
const RtcEventAlrState& event) {
rtclog::Event rtclog_event;
- rtclog_event.set_timestamp_us(event.timestamp_us_);
+ rtclog_event.set_timestamp_us(event.timestamp_us());
rtclog_event.set_type(rtclog::Event::ALR_STATE_EVENT);
auto* alr_state = rtclog_event.mutable_alr_state();
- alr_state->set_in_alr(event.in_alr_);
+ alr_state->set_in_alr(event.in_alr());
return Serialize(&rtclog_event);
}
std::string RtcEventLogEncoderLegacy::EncodeAudioNetworkAdaptation(
const RtcEventAudioNetworkAdaptation& event) {
rtclog::Event rtclog_event;
- rtclog_event.set_timestamp_us(event.timestamp_us_);
+ rtclog_event.set_timestamp_us(event.timestamp_us());
rtclog_event.set_type(rtclog::Event::AUDIO_NETWORK_ADAPTATION_EVENT);
auto* audio_network_adaptation =
rtclog_event.mutable_audio_network_adaptation();
- if (event.config_->bitrate_bps)
- audio_network_adaptation->set_bitrate_bps(*event.config_->bitrate_bps);
- if (event.config_->frame_length_ms)
+ if (event.config().bitrate_bps)
+ audio_network_adaptation->set_bitrate_bps(*event.config().bitrate_bps);
+ if (event.config().frame_length_ms)
audio_network_adaptation->set_frame_length_ms(
- *event.config_->frame_length_ms);
- if (event.config_->uplink_packet_loss_fraction) {
+ *event.config().frame_length_ms);
+ if (event.config().uplink_packet_loss_fraction) {
audio_network_adaptation->set_uplink_packet_loss_fraction(
- *event.config_->uplink_packet_loss_fraction);
+ *event.config().uplink_packet_loss_fraction);
}
- if (event.config_->enable_fec)
- audio_network_adaptation->set_enable_fec(*event.config_->enable_fec);
- if (event.config_->enable_dtx)
- audio_network_adaptation->set_enable_dtx(*event.config_->enable_dtx);
- if (event.config_->num_channels)
- audio_network_adaptation->set_num_channels(*event.config_->num_channels);
+ if (event.config().enable_fec)
+ audio_network_adaptation->set_enable_fec(*event.config().enable_fec);
+ if (event.config().enable_dtx)
+ audio_network_adaptation->set_enable_dtx(*event.config().enable_dtx);
+ if (event.config().num_channels)
+ audio_network_adaptation->set_num_channels(*event.config().num_channels);
return Serialize(&rtclog_event);
}
@@ -394,11 +394,11 @@
std::string RtcEventLogEncoderLegacy::EncodeAudioPlayout(
const RtcEventAudioPlayout& event) {
rtclog::Event rtclog_event;
- rtclog_event.set_timestamp_us(event.timestamp_us_);
+ rtclog_event.set_timestamp_us(event.timestamp_us());
rtclog_event.set_type(rtclog::Event::AUDIO_PLAYOUT_EVENT);
auto* playout_event = rtclog_event.mutable_audio_playout_event();
- playout_event->set_local_ssrc(event.ssrc_);
+ playout_event->set_local_ssrc(event.ssrc());
return Serialize(&rtclog_event);
}
@@ -406,15 +406,15 @@
std::string RtcEventLogEncoderLegacy::EncodeAudioReceiveStreamConfig(
const RtcEventAudioReceiveStreamConfig& event) {
rtclog::Event rtclog_event;
- rtclog_event.set_timestamp_us(event.timestamp_us_);
+ rtclog_event.set_timestamp_us(event.timestamp_us());
rtclog_event.set_type(rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT);
rtclog::AudioReceiveConfig* receiver_config =
rtclog_event.mutable_audio_receiver_config();
- receiver_config->set_remote_ssrc(event.config_->remote_ssrc);
- receiver_config->set_local_ssrc(event.config_->local_ssrc);
+ receiver_config->set_remote_ssrc(event.config().remote_ssrc);
+ receiver_config->set_local_ssrc(event.config().local_ssrc);
- for (const auto& e : event.config_->rtp_extensions) {
+ for (const auto& e : event.config().rtp_extensions) {
rtclog::RtpHeaderExtension* extension =
receiver_config->add_header_extensions();
extension->set_name(e.uri);
@@ -427,15 +427,15 @@
std::string RtcEventLogEncoderLegacy::EncodeAudioSendStreamConfig(
const RtcEventAudioSendStreamConfig& event) {
rtclog::Event rtclog_event;
- rtclog_event.set_timestamp_us(event.timestamp_us_);
+ rtclog_event.set_timestamp_us(event.timestamp_us());
rtclog_event.set_type(rtclog::Event::AUDIO_SENDER_CONFIG_EVENT);
rtclog::AudioSendConfig* sender_config =
rtclog_event.mutable_audio_sender_config();
- sender_config->set_ssrc(event.config_->local_ssrc);
+ sender_config->set_ssrc(event.config().local_ssrc);
- for (const auto& e : event.config_->rtp_extensions) {
+ for (const auto& e : event.config().rtp_extensions) {
rtclog::RtpHeaderExtension* extension =
sender_config->add_header_extensions();
extension->set_name(e.uri);
@@ -448,12 +448,12 @@
std::string RtcEventLogEncoderLegacy::EncodeBweUpdateDelayBased(
const RtcEventBweUpdateDelayBased& event) {
rtclog::Event rtclog_event;
- rtclog_event.set_timestamp_us(event.timestamp_us_);
+ rtclog_event.set_timestamp_us(event.timestamp_us());
rtclog_event.set_type(rtclog::Event::DELAY_BASED_BWE_UPDATE);
auto* bwe_event = rtclog_event.mutable_delay_based_bwe_update();
- bwe_event->set_bitrate_bps(event.bitrate_bps_);
- bwe_event->set_detector_state(ConvertDetectorState(event.detector_state_));
+ bwe_event->set_bitrate_bps(event.bitrate_bps());
+ bwe_event->set_detector_state(ConvertDetectorState(event.detector_state()));
return Serialize(&rtclog_event);
}
@@ -461,13 +461,13 @@
std::string RtcEventLogEncoderLegacy::EncodeBweUpdateLossBased(
const RtcEventBweUpdateLossBased& event) {
rtclog::Event rtclog_event;
- rtclog_event.set_timestamp_us(event.timestamp_us_);
+ rtclog_event.set_timestamp_us(event.timestamp_us());
rtclog_event.set_type(rtclog::Event::LOSS_BASED_BWE_UPDATE);
auto* bwe_event = rtclog_event.mutable_loss_based_bwe_update();
- bwe_event->set_bitrate_bps(event.bitrate_bps_);
- bwe_event->set_fraction_loss(event.fraction_loss_);
- bwe_event->set_total_packets(event.total_packets_);
+ bwe_event->set_bitrate_bps(event.bitrate_bps());
+ bwe_event->set_fraction_loss(event.fraction_loss());
+ bwe_event->set_total_packets(event.total_packets());
return Serialize(&rtclog_event);
}
@@ -475,15 +475,15 @@
std::string RtcEventLogEncoderLegacy::EncodeIceCandidatePairConfig(
const RtcEventIceCandidatePairConfig& event) {
rtclog::Event encoded_rtc_event;
- encoded_rtc_event.set_timestamp_us(event.timestamp_us_);
+ encoded_rtc_event.set_timestamp_us(event.timestamp_us());
encoded_rtc_event.set_type(rtclog::Event::ICE_CANDIDATE_PAIR_CONFIG);
auto* encoded_ice_event =
encoded_rtc_event.mutable_ice_candidate_pair_config();
encoded_ice_event->set_config_type(
- ConvertIceCandidatePairConfigType(event.type_));
- encoded_ice_event->set_candidate_pair_id(event.candidate_pair_id_);
- const auto& desc = event.candidate_pair_desc_;
+ ConvertIceCandidatePairConfigType(event.type()));
+ encoded_ice_event->set_candidate_pair_id(event.candidate_pair_id());
+ const auto& desc = event.candidate_pair_desc();
encoded_ice_event->set_local_candidate_type(
ConvertIceCandidateType(desc.local_candidate_type));
encoded_ice_event->set_local_relay_protocol(
@@ -504,28 +504,28 @@
std::string RtcEventLogEncoderLegacy::EncodeIceCandidatePairEvent(
const RtcEventIceCandidatePair& event) {
rtclog::Event encoded_rtc_event;
- encoded_rtc_event.set_timestamp_us(event.timestamp_us_);
+ encoded_rtc_event.set_timestamp_us(event.timestamp_us());
encoded_rtc_event.set_type(rtclog::Event::ICE_CANDIDATE_PAIR_EVENT);
auto* encoded_ice_event =
encoded_rtc_event.mutable_ice_candidate_pair_event();
encoded_ice_event->set_event_type(
- ConvertIceCandidatePairEventType(event.type_));
- encoded_ice_event->set_candidate_pair_id(event.candidate_pair_id_);
+ ConvertIceCandidatePairEventType(event.type()));
+ encoded_ice_event->set_candidate_pair_id(event.candidate_pair_id());
return Serialize(&encoded_rtc_event);
}
std::string RtcEventLogEncoderLegacy::EncodeProbeClusterCreated(
const RtcEventProbeClusterCreated& event) {
rtclog::Event rtclog_event;
- rtclog_event.set_timestamp_us(event.timestamp_us_);
+ rtclog_event.set_timestamp_us(event.timestamp_us());
rtclog_event.set_type(rtclog::Event::BWE_PROBE_CLUSTER_CREATED_EVENT);
auto* probe_cluster = rtclog_event.mutable_probe_cluster();
- probe_cluster->set_id(event.id_);
- probe_cluster->set_bitrate_bps(event.bitrate_bps_);
- probe_cluster->set_min_packets(event.min_probes_);
- probe_cluster->set_min_bytes(event.min_bytes_);
+ probe_cluster->set_id(event.id());
+ probe_cluster->set_bitrate_bps(event.bitrate_bps());
+ probe_cluster->set_min_packets(event.min_probes());
+ probe_cluster->set_min_bytes(event.min_bytes());
return Serialize(&rtclog_event);
}
@@ -533,12 +533,12 @@
std::string RtcEventLogEncoderLegacy::EncodeProbeResultFailure(
const RtcEventProbeResultFailure& event) {
rtclog::Event rtclog_event;
- rtclog_event.set_timestamp_us(event.timestamp_us_);
+ rtclog_event.set_timestamp_us(event.timestamp_us());
rtclog_event.set_type(rtclog::Event::BWE_PROBE_RESULT_EVENT);
auto* probe_result = rtclog_event.mutable_probe_result();
- probe_result->set_id(event.id_);
- probe_result->set_result(ConvertProbeResultType(event.failure_reason_));
+ probe_result->set_id(event.id());
+ probe_result->set_result(ConvertProbeResultType(event.failure_reason()));
return Serialize(&rtclog_event);
}
@@ -546,70 +546,71 @@
std::string RtcEventLogEncoderLegacy::EncodeProbeResultSuccess(
const RtcEventProbeResultSuccess& event) {
rtclog::Event rtclog_event;
- rtclog_event.set_timestamp_us(event.timestamp_us_);
+ rtclog_event.set_timestamp_us(event.timestamp_us());
rtclog_event.set_type(rtclog::Event::BWE_PROBE_RESULT_EVENT);
auto* probe_result = rtclog_event.mutable_probe_result();
- probe_result->set_id(event.id_);
+ probe_result->set_id(event.id());
probe_result->set_result(rtclog::BweProbeResult::SUCCESS);
- probe_result->set_bitrate_bps(event.bitrate_bps_);
+ probe_result->set_bitrate_bps(event.bitrate_bps());
return Serialize(&rtclog_event);
}
std::string RtcEventLogEncoderLegacy::EncodeRtcpPacketIncoming(
const RtcEventRtcpPacketIncoming& event) {
- return EncodeRtcpPacket(event.timestamp_us_, event.packet_, true);
+ return EncodeRtcpPacket(event.timestamp_us(), event.packet(), true);
}
std::string RtcEventLogEncoderLegacy::EncodeRtcpPacketOutgoing(
const RtcEventRtcpPacketOutgoing& event) {
- return EncodeRtcpPacket(event.timestamp_us_, event.packet_, false);
+ return EncodeRtcpPacket(event.timestamp_us(), event.packet(), false);
}
std::string RtcEventLogEncoderLegacy::EncodeRtpPacketIncoming(
const RtcEventRtpPacketIncoming& event) {
- return EncodeRtpPacket(event.timestamp_us_, event.header_,
+ return EncodeRtpPacket(event.timestamp_us(), event.header(),
event.packet_length(), PacedPacketInfo::kNotAProbe,
true);
}
std::string RtcEventLogEncoderLegacy::EncodeRtpPacketOutgoing(
const RtcEventRtpPacketOutgoing& event) {
- return EncodeRtpPacket(event.timestamp_us_, event.header_,
- event.packet_length(), event.probe_cluster_id_, false);
+ return EncodeRtpPacket(event.timestamp_us(), event.header(),
+ event.packet_length(), event.probe_cluster_id(),
+ false);
}
std::string RtcEventLogEncoderLegacy::EncodeVideoReceiveStreamConfig(
const RtcEventVideoReceiveStreamConfig& event) {
rtclog::Event rtclog_event;
- rtclog_event.set_timestamp_us(event.timestamp_us_);
+ rtclog_event.set_timestamp_us(event.timestamp_us());
rtclog_event.set_type(rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT);
rtclog::VideoReceiveConfig* receiver_config =
rtclog_event.mutable_video_receiver_config();
- receiver_config->set_remote_ssrc(event.config_->remote_ssrc);
- receiver_config->set_local_ssrc(event.config_->local_ssrc);
+ receiver_config->set_remote_ssrc(event.config().remote_ssrc);
+ receiver_config->set_local_ssrc(event.config().local_ssrc);
// TODO(perkj): Add field for rsid.
- receiver_config->set_rtcp_mode(ConvertRtcpMode(event.config_->rtcp_mode));
- receiver_config->set_remb(event.config_->remb);
+ receiver_config->set_rtcp_mode(ConvertRtcpMode(event.config().rtcp_mode));
+ receiver_config->set_remb(event.config().remb);
- for (const auto& e : event.config_->rtp_extensions) {
+ for (const auto& e : event.config().rtp_extensions) {
rtclog::RtpHeaderExtension* extension =
receiver_config->add_header_extensions();
extension->set_name(e.uri);
extension->set_id(e.id);
}
- for (const auto& d : event.config_->codecs) {
+ for (const auto& d : event.config().codecs) {
rtclog::DecoderConfig* decoder = receiver_config->add_decoders();
decoder->set_name(d.payload_name);
decoder->set_payload_type(d.payload_type);
if (d.rtx_payload_type != 0) {
rtclog::RtxMap* rtx = receiver_config->add_rtx_map();
rtx->set_payload_type(d.payload_type);
- rtx->mutable_config()->set_rtx_ssrc(event.config_->rtx_ssrc);
+ rtx->mutable_config()->set_rtx_ssrc(event.config().rtx_ssrc);
rtx->mutable_config()->set_rtx_payload_type(d.rtx_payload_type);
}
}
@@ -620,19 +621,19 @@
std::string RtcEventLogEncoderLegacy::EncodeVideoSendStreamConfig(
const RtcEventVideoSendStreamConfig& event) {
rtclog::Event rtclog_event;
- rtclog_event.set_timestamp_us(event.timestamp_us_);
+ rtclog_event.set_timestamp_us(event.timestamp_us());
rtclog_event.set_type(rtclog::Event::VIDEO_SENDER_CONFIG_EVENT);
rtclog::VideoSendConfig* sender_config =
rtclog_event.mutable_video_sender_config();
// TODO(perkj): rtclog::VideoSendConfig should only contain one SSRC.
- sender_config->add_ssrcs(event.config_->local_ssrc);
- if (event.config_->rtx_ssrc != 0) {
- sender_config->add_rtx_ssrcs(event.config_->rtx_ssrc);
+ sender_config->add_ssrcs(event.config().local_ssrc);
+ if (event.config().rtx_ssrc != 0) {
+ sender_config->add_rtx_ssrcs(event.config().rtx_ssrc);
}
- for (const auto& e : event.config_->rtp_extensions) {
+ for (const auto& e : event.config().rtp_extensions) {
rtclog::RtpHeaderExtension* extension =
sender_config->add_header_extensions();
extension->set_name(e.uri);
@@ -641,13 +642,13 @@
// TODO(perkj): rtclog::VideoSendConfig should contain many possible codec
// configurations.
- for (const auto& codec : event.config_->codecs) {
+ for (const auto& codec : event.config().codecs) {
sender_config->set_rtx_payload_type(codec.rtx_payload_type);
rtclog::EncoderConfig* encoder = sender_config->mutable_encoder();
encoder->set_name(codec.payload_name);
encoder->set_payload_type(codec.payload_type);
- if (event.config_->codecs.size() > 1) {
+ if (event.config().codecs.size() > 1) {
RTC_LOG(WARNING)
<< "LogVideoSendStreamConfig currently only supports one "
<< "codec. Logging codec :" << codec.payload_name;
diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc b/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc
index 7a02087..f8362ab 100644
--- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc
+++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc
@@ -296,11 +296,11 @@
// Base event
const EventType* const base_event = batch[0];
- proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
+ proto_batch->set_timestamp_ms(base_event->timestamp_us() / 1000);
{
uint8_t buffer[IP_PACKET_SIZE];
size_t buffer_length =
- RemoveNonWhitelistedRtcpBlocks(base_event->packet_, buffer);
+ RemoveNonWhitelistedRtcpBlocks(base_event->packet(), buffer);
proto_batch->set_raw_packet(buffer, buffer_length);
}
@@ -316,9 +316,9 @@
// timestamp_ms
for (size_t i = 0; i < values.size(); ++i) {
const EventType* event = batch[i + 1];
- values[i] = event->timestamp_us_ / 1000;
+ values[i] = event->timestamp_us() / 1000;
}
- encoded_deltas = EncodeDeltas(base_event->timestamp_us_ / 1000, values);
+ encoded_deltas = EncodeDeltas(base_event->timestamp_us() / 1000, values);
if (!encoded_deltas.empty()) {
proto_batch->set_timestamp_ms_deltas(encoded_deltas);
}
@@ -327,11 +327,11 @@
std::vector<std::string> scrubed_packets(batch.size() - 1);
for (size_t i = 0; i < scrubed_packets.size(); ++i) {
const EventType* event = batch[i + 1];
- scrubed_packets[i].resize(event->packet_.size());
+ scrubed_packets[i].resize(event->packet().size());
static_assert(sizeof(std::string::value_type) == sizeof(uint8_t), "");
const size_t buffer_length = RemoveNonWhitelistedRtcpBlocks(
- event->packet_, reinterpret_cast<uint8_t*>(&scrubed_packets[i][0]));
- if (buffer_length < event->packet_.size()) {
+ event->packet(), reinterpret_cast<uint8_t*>(&scrubed_packets[i][0]));
+ if (buffer_length < event->packet().size()) {
scrubed_packets[i].resize(buffer_length);
}
}
@@ -347,22 +347,22 @@
// Base event
const EventType* const base_event = batch[0];
- proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
- proto_batch->set_marker(base_event->header_.Marker());
+ proto_batch->set_timestamp_ms(base_event->timestamp_us() / 1000);
+ proto_batch->set_marker(base_event->header().Marker());
// TODO(terelius): Is payload type needed?
- proto_batch->set_payload_type(base_event->header_.PayloadType());
- proto_batch->set_sequence_number(base_event->header_.SequenceNumber());
- proto_batch->set_rtp_timestamp(base_event->header_.Timestamp());
- proto_batch->set_ssrc(base_event->header_.Ssrc());
- proto_batch->set_payload_size(base_event->payload_length_);
- proto_batch->set_header_size(base_event->header_length_);
- proto_batch->set_padding_size(base_event->padding_length_);
+ proto_batch->set_payload_type(base_event->header().PayloadType());
+ proto_batch->set_sequence_number(base_event->header().SequenceNumber());
+ proto_batch->set_rtp_timestamp(base_event->header().Timestamp());
+ proto_batch->set_ssrc(base_event->header().Ssrc());
+ proto_batch->set_payload_size(base_event->payload_length());
+ proto_batch->set_header_size(base_event->header_length());
+ proto_batch->set_padding_size(base_event->padding_length());
// Add header extensions (base event).
absl::optional<uint64_t> base_transport_sequence_number;
{
uint16_t seqnum;
- if (base_event->header_.template GetExtension<TransportSequenceNumber>(
+ if (base_event->header().template GetExtension<TransportSequenceNumber>(
&seqnum)) {
proto_batch->set_transport_sequence_number(seqnum);
base_transport_sequence_number = seqnum;
@@ -372,7 +372,7 @@
absl::optional<uint64_t> unsigned_base_transmission_time_offset;
{
int32_t offset;
- if (base_event->header_.template GetExtension<TransmissionOffset>(
+ if (base_event->header().template GetExtension<TransmissionOffset>(
&offset)) {
proto_batch->set_transmission_time_offset(offset);
unsigned_base_transmission_time_offset = ToUnsigned(offset);
@@ -382,7 +382,7 @@
absl::optional<uint64_t> base_absolute_send_time;
{
uint32_t sendtime;
- if (base_event->header_.template GetExtension<AbsoluteSendTime>(
+ if (base_event->header().template GetExtension<AbsoluteSendTime>(
&sendtime)) {
proto_batch->set_absolute_send_time(sendtime);
base_absolute_send_time = sendtime;
@@ -392,7 +392,7 @@
absl::optional<uint64_t> base_video_rotation;
{
VideoRotation video_rotation;
- if (base_event->header_.template GetExtension<VideoOrientation>(
+ if (base_event->header().template GetExtension<VideoOrientation>(
&video_rotation)) {
proto_batch->set_video_rotation(
ConvertVideoRotationToCVOByte(video_rotation));
@@ -405,8 +405,8 @@
{
bool voice_activity;
uint8_t audio_level;
- if (base_event->header_.template GetExtension<AudioLevel>(&voice_activity,
- &audio_level)) {
+ if (base_event->header().template GetExtension<AudioLevel>(&voice_activity,
+ &audio_level)) {
RTC_DCHECK_LE(audio_level, 0x7Fu);
base_audio_level = audio_level;
proto_batch->set_audio_level(audio_level);
@@ -428,9 +428,9 @@
// timestamp_ms (event)
for (size_t i = 0; i < values.size(); ++i) {
const EventType* event = batch[i + 1];
- values[i] = event->timestamp_us_ / 1000;
+ values[i] = event->timestamp_us() / 1000;
}
- encoded_deltas = EncodeDeltas(base_event->timestamp_us_ / 1000, values);
+ encoded_deltas = EncodeDeltas(base_event->timestamp_us() / 1000, values);
if (!encoded_deltas.empty()) {
proto_batch->set_timestamp_ms_deltas(encoded_deltas);
}
@@ -438,9 +438,9 @@
// marker (RTP base)
for (size_t i = 0; i < values.size(); ++i) {
const EventType* event = batch[i + 1];
- values[i] = event->header_.Marker();
+ values[i] = event->header().Marker();
}
- encoded_deltas = EncodeDeltas(base_event->header_.Marker(), values);
+ encoded_deltas = EncodeDeltas(base_event->header().Marker(), values);
if (!encoded_deltas.empty()) {
proto_batch->set_marker_deltas(encoded_deltas);
}
@@ -448,9 +448,9 @@
// payload_type (RTP base)
for (size_t i = 0; i < values.size(); ++i) {
const EventType* event = batch[i + 1];
- values[i] = event->header_.PayloadType();
+ values[i] = event->header().PayloadType();
}
- encoded_deltas = EncodeDeltas(base_event->header_.PayloadType(), values);
+ encoded_deltas = EncodeDeltas(base_event->header().PayloadType(), values);
if (!encoded_deltas.empty()) {
proto_batch->set_payload_type_deltas(encoded_deltas);
}
@@ -458,9 +458,9 @@
// sequence_number (RTP base)
for (size_t i = 0; i < values.size(); ++i) {
const EventType* event = batch[i + 1];
- values[i] = event->header_.SequenceNumber();
+ values[i] = event->header().SequenceNumber();
}
- encoded_deltas = EncodeDeltas(base_event->header_.SequenceNumber(), values);
+ encoded_deltas = EncodeDeltas(base_event->header().SequenceNumber(), values);
if (!encoded_deltas.empty()) {
proto_batch->set_sequence_number_deltas(encoded_deltas);
}
@@ -468,9 +468,9 @@
// rtp_timestamp (RTP base)
for (size_t i = 0; i < values.size(); ++i) {
const EventType* event = batch[i + 1];
- values[i] = event->header_.Timestamp();
+ values[i] = event->header().Timestamp();
}
- encoded_deltas = EncodeDeltas(base_event->header_.Timestamp(), values);
+ encoded_deltas = EncodeDeltas(base_event->header().Timestamp(), values);
if (!encoded_deltas.empty()) {
proto_batch->set_rtp_timestamp_deltas(encoded_deltas);
}
@@ -478,9 +478,9 @@
// ssrc (RTP base)
for (size_t i = 0; i < values.size(); ++i) {
const EventType* event = batch[i + 1];
- values[i] = event->header_.Ssrc();
+ values[i] = event->header().Ssrc();
}
- encoded_deltas = EncodeDeltas(base_event->header_.Ssrc(), values);
+ encoded_deltas = EncodeDeltas(base_event->header().Ssrc(), values);
if (!encoded_deltas.empty()) {
proto_batch->set_ssrc_deltas(encoded_deltas);
}
@@ -488,9 +488,9 @@
// payload_size (RTP base)
for (size_t i = 0; i < values.size(); ++i) {
const EventType* event = batch[i + 1];
- values[i] = event->payload_length_;
+ values[i] = event->payload_length();
}
- encoded_deltas = EncodeDeltas(base_event->payload_length_, values);
+ encoded_deltas = EncodeDeltas(base_event->payload_length(), values);
if (!encoded_deltas.empty()) {
proto_batch->set_payload_size_deltas(encoded_deltas);
}
@@ -498,9 +498,9 @@
// header_size (RTP base)
for (size_t i = 0; i < values.size(); ++i) {
const EventType* event = batch[i + 1];
- values[i] = event->header_length_;
+ values[i] = event->header_length();
}
- encoded_deltas = EncodeDeltas(base_event->header_length_, values);
+ encoded_deltas = EncodeDeltas(base_event->header_length(), values);
if (!encoded_deltas.empty()) {
proto_batch->set_header_size_deltas(encoded_deltas);
}
@@ -508,9 +508,9 @@
// padding_size (RTP base)
for (size_t i = 0; i < values.size(); ++i) {
const EventType* event = batch[i + 1];
- values[i] = event->padding_length_;
+ values[i] = event->padding_length();
}
- encoded_deltas = EncodeDeltas(base_event->padding_length_, values);
+ encoded_deltas = EncodeDeltas(base_event->padding_length(), values);
if (!encoded_deltas.empty()) {
proto_batch->set_padding_size_deltas(encoded_deltas);
}
@@ -519,7 +519,7 @@
for (size_t i = 0; i < values.size(); ++i) {
const EventType* event = batch[i + 1];
uint16_t seqnum;
- if (event->header_.template GetExtension<TransportSequenceNumber>(
+ if (event->header().template GetExtension<TransportSequenceNumber>(
&seqnum)) {
values[i] = seqnum;
} else {
@@ -535,7 +535,7 @@
for (size_t i = 0; i < values.size(); ++i) {
const EventType* event = batch[i + 1];
int32_t offset;
- if (event->header_.template GetExtension<TransmissionOffset>(&offset)) {
+ if (event->header().template GetExtension<TransmissionOffset>(&offset)) {
values[i] = ToUnsigned(offset);
} else {
values[i].reset();
@@ -550,7 +550,7 @@
for (size_t i = 0; i < values.size(); ++i) {
const EventType* event = batch[i + 1];
uint32_t sendtime;
- if (event->header_.template GetExtension<AbsoluteSendTime>(&sendtime)) {
+ if (event->header().template GetExtension<AbsoluteSendTime>(&sendtime)) {
values[i] = sendtime;
} else {
values[i].reset();
@@ -565,7 +565,7 @@
for (size_t i = 0; i < values.size(); ++i) {
const EventType* event = batch[i + 1];
VideoRotation video_rotation;
- if (event->header_.template GetExtension<VideoOrientation>(
+ if (event->header().template GetExtension<VideoOrientation>(
&video_rotation)) {
values[i] = ConvertVideoRotationToCVOByte(video_rotation);
} else {
@@ -582,8 +582,8 @@
const EventType* event = batch[i + 1];
bool voice_activity;
uint8_t audio_level;
- if (event->header_.template GetExtension<AudioLevel>(&voice_activity,
- &audio_level)) {
+ if (event->header().template GetExtension<AudioLevel>(&voice_activity,
+ &audio_level)) {
RTC_DCHECK_LE(audio_level, 0x7Fu);
values[i] = audio_level;
} else {
@@ -600,8 +600,8 @@
const EventType* event = batch[i + 1];
bool voice_activity;
uint8_t audio_level;
- if (event->header_.template GetExtension<AudioLevel>(&voice_activity,
- &audio_level)) {
+ if (event->header().template GetExtension<AudioLevel>(&voice_activity,
+ &audio_level)) {
RTC_DCHECK_LE(audio_level, 0x7Fu);
values[i] = voice_activity;
} else {
@@ -741,14 +741,14 @@
case RtcEvent::Type::RtpPacketIncoming: {
auto* rtc_event =
static_cast<const RtcEventRtpPacketIncoming* const>(it->get());
- auto& v = incoming_rtp_packets[rtc_event->header_.Ssrc()];
+ auto& v = incoming_rtp_packets[rtc_event->header().Ssrc()];
v.emplace_back(rtc_event);
break;
}
case RtcEvent::Type::RtpPacketOutgoing: {
auto* rtc_event =
static_cast<const RtcEventRtpPacketOutgoing* const>(it->get());
- auto& v = outgoing_rtp_packets[rtc_event->header_.Ssrc()];
+ auto& v = outgoing_rtp_packets[rtc_event->header().Ssrc()];
v.emplace_back(rtc_event);
break;
}
@@ -811,8 +811,8 @@
rtclog2::EventStream* event_stream) {
for (const RtcEventAlrState* base_event : batch) {
rtclog2::AlrState* proto_batch = event_stream->add_alr_states();
- proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
- proto_batch->set_in_alr(base_event->in_alr_);
+ proto_batch->set_timestamp_ms(base_event->timestamp_us() / 1000);
+ proto_batch->set_in_alr(base_event->in_alr());
}
// TODO(terelius): Should we delta-compress this event type?
}
@@ -827,26 +827,26 @@
const RtcEventAudioNetworkAdaptation* const base_event = batch[0];
rtclog2::AudioNetworkAdaptations* proto_batch =
event_stream->add_audio_network_adaptations();
- proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
- if (base_event->config_->bitrate_bps.has_value())
- proto_batch->set_bitrate_bps(base_event->config_->bitrate_bps.value());
- if (base_event->config_->frame_length_ms.has_value()) {
+ proto_batch->set_timestamp_ms(base_event->timestamp_us() / 1000);
+ if (base_event->config().bitrate_bps.has_value())
+ proto_batch->set_bitrate_bps(base_event->config().bitrate_bps.value());
+ if (base_event->config().frame_length_ms.has_value()) {
proto_batch->set_frame_length_ms(
- base_event->config_->frame_length_ms.value());
+ base_event->config().frame_length_ms.value());
}
absl::optional<uint64_t> base_uplink_packet_loss_fraction;
- if (base_event->config_->uplink_packet_loss_fraction.has_value()) {
+ if (base_event->config().uplink_packet_loss_fraction.has_value()) {
base_uplink_packet_loss_fraction = ConvertPacketLossFractionToProtoFormat(
- base_event->config_->uplink_packet_loss_fraction.value());
+ base_event->config().uplink_packet_loss_fraction.value());
proto_batch->set_uplink_packet_loss_fraction(
base_uplink_packet_loss_fraction.value());
}
- if (base_event->config_->enable_fec.has_value())
- proto_batch->set_enable_fec(base_event->config_->enable_fec.value());
- if (base_event->config_->enable_dtx.has_value())
- proto_batch->set_enable_dtx(base_event->config_->enable_dtx.value());
- if (base_event->config_->num_channels.has_value())
- proto_batch->set_num_channels(base_event->config_->num_channels.value());
+ if (base_event->config().enable_fec.has_value())
+ proto_batch->set_enable_fec(base_event->config().enable_fec.value());
+ if (base_event->config().enable_dtx.has_value())
+ proto_batch->set_enable_dtx(base_event->config().enable_dtx.value());
+ if (base_event->config().num_channels.has_value())
+ proto_batch->set_num_channels(base_event->config().num_channels.value());
if (batch.size() == 1)
return;
@@ -859,9 +859,9 @@
// timestamp_ms
for (size_t i = 0; i < values.size(); ++i) {
const RtcEventAudioNetworkAdaptation* event = batch[i + 1];
- values[i] = event->timestamp_us_ / 1000;
+ values[i] = event->timestamp_us() / 1000;
}
- encoded_deltas = EncodeDeltas(base_event->timestamp_us_ / 1000, values);
+ encoded_deltas = EncodeDeltas(base_event->timestamp_us() / 1000, values);
if (!encoded_deltas.empty()) {
proto_batch->set_timestamp_ms_deltas(encoded_deltas);
}
@@ -869,15 +869,15 @@
// bitrate_bps
for (size_t i = 0; i < values.size(); ++i) {
const RtcEventAudioNetworkAdaptation* event = batch[i + 1];
- if (event->config_->bitrate_bps.has_value()) {
- values[i] = ToUnsigned(event->config_->bitrate_bps.value());
+ if (event->config().bitrate_bps.has_value()) {
+ values[i] = ToUnsigned(event->config().bitrate_bps.value());
} else {
values[i].reset();
}
}
const absl::optional<uint64_t> unsigned_base_bitrate_bps =
- base_event->config_->bitrate_bps.has_value()
- ? ToUnsigned(base_event->config_->bitrate_bps.value())
+ base_event->config().bitrate_bps.has_value()
+ ? ToUnsigned(base_event->config().bitrate_bps.value())
: absl::optional<uint64_t>();
encoded_deltas = EncodeDeltas(unsigned_base_bitrate_bps, values);
if (!encoded_deltas.empty()) {
@@ -887,15 +887,15 @@
// frame_length_ms
for (size_t i = 0; i < values.size(); ++i) {
const RtcEventAudioNetworkAdaptation* event = batch[i + 1];
- if (event->config_->frame_length_ms.has_value()) {
- values[i] = ToUnsigned(event->config_->frame_length_ms.value());
+ if (event->config().frame_length_ms.has_value()) {
+ values[i] = ToUnsigned(event->config().frame_length_ms.value());
} else {
values[i].reset();
}
}
const absl::optional<uint64_t> unsigned_base_frame_length_ms =
- base_event->config_->frame_length_ms.has_value()
- ? ToUnsigned(base_event->config_->frame_length_ms.value())
+ base_event->config().frame_length_ms.has_value()
+ ? ToUnsigned(base_event->config().frame_length_ms.value())
: absl::optional<uint64_t>();
encoded_deltas = EncodeDeltas(unsigned_base_frame_length_ms, values);
if (!encoded_deltas.empty()) {
@@ -905,9 +905,9 @@
// uplink_packet_loss_fraction
for (size_t i = 0; i < values.size(); ++i) {
const RtcEventAudioNetworkAdaptation* event = batch[i + 1];
- if (event->config_->uplink_packet_loss_fraction.has_value()) {
+ if (event->config().uplink_packet_loss_fraction.has_value()) {
values[i] = ConvertPacketLossFractionToProtoFormat(
- event->config_->uplink_packet_loss_fraction.value());
+ event->config().uplink_packet_loss_fraction.value());
} else {
values[i].reset();
}
@@ -920,9 +920,9 @@
// enable_fec
for (size_t i = 0; i < values.size(); ++i) {
const RtcEventAudioNetworkAdaptation* event = batch[i + 1];
- values[i] = event->config_->enable_fec;
+ values[i] = event->config().enable_fec;
}
- encoded_deltas = EncodeDeltas(base_event->config_->enable_fec, values);
+ encoded_deltas = EncodeDeltas(base_event->config().enable_fec, values);
if (!encoded_deltas.empty()) {
proto_batch->set_enable_fec_deltas(encoded_deltas);
}
@@ -930,9 +930,9 @@
// enable_dtx
for (size_t i = 0; i < values.size(); ++i) {
const RtcEventAudioNetworkAdaptation* event = batch[i + 1];
- values[i] = event->config_->enable_dtx;
+ values[i] = event->config().enable_dtx;
}
- encoded_deltas = EncodeDeltas(base_event->config_->enable_dtx, values);
+ encoded_deltas = EncodeDeltas(base_event->config().enable_dtx, values);
if (!encoded_deltas.empty()) {
proto_batch->set_enable_dtx_deltas(encoded_deltas);
}
@@ -940,9 +940,9 @@
// num_channels
for (size_t i = 0; i < values.size(); ++i) {
const RtcEventAudioNetworkAdaptation* event = batch[i + 1];
- values[i] = event->config_->num_channels;
+ values[i] = event->config().num_channels;
}
- encoded_deltas = EncodeDeltas(base_event->config_->num_channels, values);
+ encoded_deltas = EncodeDeltas(base_event->config().num_channels, values);
if (!encoded_deltas.empty()) {
proto_batch->set_num_channels_deltas(encoded_deltas);
}
@@ -958,8 +958,8 @@
const RtcEventAudioPlayout* const base_event = batch[0];
rtclog2::AudioPlayoutEvents* proto_batch =
event_stream->add_audio_playout_events();
- proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
- proto_batch->set_local_ssrc(base_event->ssrc_);
+ proto_batch->set_timestamp_ms(base_event->timestamp_us() / 1000);
+ proto_batch->set_local_ssrc(base_event->ssrc());
if (batch.size() == 1)
return;
@@ -972,9 +972,9 @@
// timestamp_ms
for (size_t i = 0; i < values.size(); ++i) {
const RtcEventAudioPlayout* event = batch[i + 1];
- values[i] = event->timestamp_us_ / 1000;
+ values[i] = event->timestamp_us() / 1000;
}
- encoded_deltas = EncodeDeltas(base_event->timestamp_us_ / 1000, values);
+ encoded_deltas = EncodeDeltas(base_event->timestamp_us() / 1000, values);
if (!encoded_deltas.empty()) {
proto_batch->set_timestamp_ms_deltas(encoded_deltas);
}
@@ -982,9 +982,9 @@
// local_ssrc
for (size_t i = 0; i < values.size(); ++i) {
const RtcEventAudioPlayout* event = batch[i + 1];
- values[i] = event->ssrc_;
+ values[i] = event->ssrc();
}
- encoded_deltas = EncodeDeltas(base_event->ssrc_, values);
+ encoded_deltas = EncodeDeltas(base_event->ssrc(), values);
if (!encoded_deltas.empty()) {
proto_batch->set_local_ssrc_deltas(encoded_deltas);
}
@@ -996,16 +996,16 @@
for (const RtcEventAudioReceiveStreamConfig* base_event : batch) {
rtclog2::AudioRecvStreamConfig* proto_batch =
event_stream->add_audio_recv_stream_configs();
- proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
- proto_batch->set_remote_ssrc(base_event->config_->remote_ssrc);
- proto_batch->set_local_ssrc(base_event->config_->local_ssrc);
- if (!base_event->config_->rsid.empty())
- proto_batch->set_rsid(base_event->config_->rsid);
+ proto_batch->set_timestamp_ms(base_event->timestamp_us() / 1000);
+ proto_batch->set_remote_ssrc(base_event->config().remote_ssrc);
+ proto_batch->set_local_ssrc(base_event->config().local_ssrc);
+ if (!base_event->config().rsid.empty())
+ proto_batch->set_rsid(base_event->config().rsid);
rtclog2::RtpHeaderExtensionConfig* proto_config =
proto_batch->mutable_header_extensions();
bool has_recognized_extensions =
- ConvertToProtoFormat(base_event->config_->rtp_extensions, proto_config);
+ ConvertToProtoFormat(base_event->config().rtp_extensions, proto_config);
if (!has_recognized_extensions)
proto_batch->clear_header_extensions();
}
@@ -1017,15 +1017,15 @@
for (const RtcEventAudioSendStreamConfig* base_event : batch) {
rtclog2::AudioSendStreamConfig* proto_batch =
event_stream->add_audio_send_stream_configs();
- proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
- proto_batch->set_ssrc(base_event->config_->local_ssrc);
- if (!base_event->config_->rsid.empty())
- proto_batch->set_rsid(base_event->config_->rsid);
+ proto_batch->set_timestamp_ms(base_event->timestamp_us() / 1000);
+ proto_batch->set_ssrc(base_event->config().local_ssrc);
+ if (!base_event->config().rsid.empty())
+ proto_batch->set_rsid(base_event->config().rsid);
rtclog2::RtpHeaderExtensionConfig* proto_config =
proto_batch->mutable_header_extensions();
bool has_recognized_extensions =
- ConvertToProtoFormat(base_event->config_->rtp_extensions, proto_config);
+ ConvertToProtoFormat(base_event->config().rtp_extensions, proto_config);
if (!has_recognized_extensions)
proto_batch->clear_header_extensions();
}
@@ -1041,10 +1041,10 @@
const RtcEventBweUpdateDelayBased* const base_event = batch[0];
rtclog2::DelayBasedBweUpdates* proto_batch =
event_stream->add_delay_based_bwe_updates();
- proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
- proto_batch->set_bitrate_bps(base_event->bitrate_bps_);
+ proto_batch->set_timestamp_ms(base_event->timestamp_us() / 1000);
+ proto_batch->set_bitrate_bps(base_event->bitrate_bps());
proto_batch->set_detector_state(
- ConvertToProtoFormat(base_event->detector_state_));
+ ConvertToProtoFormat(base_event->detector_state()));
if (batch.size() == 1)
return;
@@ -1057,9 +1057,9 @@
// timestamp_ms
for (size_t i = 0; i < values.size(); ++i) {
const RtcEventBweUpdateDelayBased* event = batch[i + 1];
- values[i] = event->timestamp_us_ / 1000;
+ values[i] = event->timestamp_us() / 1000;
}
- encoded_deltas = EncodeDeltas(base_event->timestamp_us_ / 1000, values);
+ encoded_deltas = EncodeDeltas(base_event->timestamp_us() / 1000, values);
if (!encoded_deltas.empty()) {
proto_batch->set_timestamp_ms_deltas(encoded_deltas);
}
@@ -1067,9 +1067,9 @@
// bitrate_bps
for (size_t i = 0; i < values.size(); ++i) {
const RtcEventBweUpdateDelayBased* event = batch[i + 1];
- values[i] = event->bitrate_bps_;
+ values[i] = event->bitrate_bps();
}
- encoded_deltas = EncodeDeltas(base_event->bitrate_bps_, values);
+ encoded_deltas = EncodeDeltas(base_event->bitrate_bps(), values);
if (!encoded_deltas.empty()) {
proto_batch->set_bitrate_bps_deltas(encoded_deltas);
}
@@ -1078,10 +1078,10 @@
for (size_t i = 0; i < values.size(); ++i) {
const RtcEventBweUpdateDelayBased* event = batch[i + 1];
values[i] =
- static_cast<uint64_t>(ConvertToProtoFormat(event->detector_state_));
+ static_cast<uint64_t>(ConvertToProtoFormat(event->detector_state()));
}
encoded_deltas = EncodeDeltas(
- static_cast<uint64_t>(ConvertToProtoFormat(base_event->detector_state_)),
+ static_cast<uint64_t>(ConvertToProtoFormat(base_event->detector_state())),
values);
if (!encoded_deltas.empty()) {
proto_batch->set_detector_state_deltas(encoded_deltas);
@@ -1098,10 +1098,10 @@
const RtcEventBweUpdateLossBased* const base_event = batch[0];
rtclog2::LossBasedBweUpdates* proto_batch =
event_stream->add_loss_based_bwe_updates();
- proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
- proto_batch->set_bitrate_bps(base_event->bitrate_bps_);
- proto_batch->set_fraction_loss(base_event->fraction_loss_);
- proto_batch->set_total_packets(base_event->total_packets_);
+ proto_batch->set_timestamp_ms(base_event->timestamp_us() / 1000);
+ proto_batch->set_bitrate_bps(base_event->bitrate_bps());
+ proto_batch->set_fraction_loss(base_event->fraction_loss());
+ proto_batch->set_total_packets(base_event->total_packets());
if (batch.size() == 1)
return;
@@ -1114,9 +1114,9 @@
// timestamp_ms
for (size_t i = 0; i < values.size(); ++i) {
const RtcEventBweUpdateLossBased* event = batch[i + 1];
- values[i] = event->timestamp_us_ / 1000;
+ values[i] = event->timestamp_us() / 1000;
}
- encoded_deltas = EncodeDeltas(base_event->timestamp_us_ / 1000, values);
+ encoded_deltas = EncodeDeltas(base_event->timestamp_us() / 1000, values);
if (!encoded_deltas.empty()) {
proto_batch->set_timestamp_ms_deltas(encoded_deltas);
}
@@ -1124,9 +1124,9 @@
// bitrate_bps
for (size_t i = 0; i < values.size(); ++i) {
const RtcEventBweUpdateLossBased* event = batch[i + 1];
- values[i] = event->bitrate_bps_;
+ values[i] = event->bitrate_bps();
}
- encoded_deltas = EncodeDeltas(base_event->bitrate_bps_, values);
+ encoded_deltas = EncodeDeltas(base_event->bitrate_bps(), values);
if (!encoded_deltas.empty()) {
proto_batch->set_bitrate_bps_deltas(encoded_deltas);
}
@@ -1134,9 +1134,9 @@
// fraction_loss
for (size_t i = 0; i < values.size(); ++i) {
const RtcEventBweUpdateLossBased* event = batch[i + 1];
- values[i] = event->fraction_loss_;
+ values[i] = event->fraction_loss();
}
- encoded_deltas = EncodeDeltas(base_event->fraction_loss_, values);
+ encoded_deltas = EncodeDeltas(base_event->fraction_loss(), values);
if (!encoded_deltas.empty()) {
proto_batch->set_fraction_loss_deltas(encoded_deltas);
}
@@ -1144,9 +1144,9 @@
// total_packets
for (size_t i = 0; i < values.size(); ++i) {
const RtcEventBweUpdateLossBased* event = batch[i + 1];
- values[i] = event->total_packets_;
+ values[i] = event->total_packets();
}
- encoded_deltas = EncodeDeltas(base_event->total_packets_, values);
+ encoded_deltas = EncodeDeltas(base_event->total_packets(), values);
if (!encoded_deltas.empty()) {
proto_batch->set_total_packets_deltas(encoded_deltas);
}
@@ -1157,11 +1157,11 @@
rtclog2::EventStream* event_stream) {
for (const RtcEventProbeClusterCreated* base_event : batch) {
rtclog2::BweProbeCluster* proto_batch = event_stream->add_probe_clusters();
- proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
- proto_batch->set_id(base_event->id_);
- proto_batch->set_bitrate_bps(base_event->bitrate_bps_);
- proto_batch->set_min_packets(base_event->min_probes_);
- proto_batch->set_min_bytes(base_event->min_bytes_);
+ proto_batch->set_timestamp_ms(base_event->timestamp_us() / 1000);
+ proto_batch->set_id(base_event->id());
+ proto_batch->set_bitrate_bps(base_event->bitrate_bps());
+ proto_batch->set_min_packets(base_event->min_probes());
+ proto_batch->set_min_bytes(base_event->min_bytes());
}
}
@@ -1171,9 +1171,10 @@
for (const RtcEventProbeResultFailure* base_event : batch) {
rtclog2::BweProbeResultFailure* proto_batch =
event_stream->add_probe_failure();
- proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
- proto_batch->set_id(base_event->id_);
- proto_batch->set_failure(ConvertToProtoFormat(base_event->failure_reason_));
+ proto_batch->set_timestamp_ms(base_event->timestamp_us() / 1000);
+ proto_batch->set_id(base_event->id());
+ proto_batch->set_failure(
+ ConvertToProtoFormat(base_event->failure_reason()));
}
// TODO(terelius): Should we delta-compress this event type?
}
@@ -1184,9 +1185,9 @@
for (const RtcEventProbeResultSuccess* base_event : batch) {
rtclog2::BweProbeResultSuccess* proto_batch =
event_stream->add_probe_success();
- proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
- proto_batch->set_id(base_event->id_);
- proto_batch->set_bitrate_bps(base_event->bitrate_bps_);
+ proto_batch->set_timestamp_ms(base_event->timestamp_us() / 1000);
+ proto_batch->set_id(base_event->id());
+ proto_batch->set_bitrate_bps(base_event->bitrate_bps());
}
// TODO(terelius): Should we delta-compress this event type?
}
@@ -1235,17 +1236,17 @@
for (const RtcEventVideoReceiveStreamConfig* base_event : batch) {
rtclog2::VideoRecvStreamConfig* proto_batch =
event_stream->add_video_recv_stream_configs();
- proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
- proto_batch->set_remote_ssrc(base_event->config_->remote_ssrc);
- proto_batch->set_local_ssrc(base_event->config_->local_ssrc);
- proto_batch->set_rtx_ssrc(base_event->config_->rtx_ssrc);
- if (!base_event->config_->rsid.empty())
- proto_batch->set_rsid(base_event->config_->rsid);
+ proto_batch->set_timestamp_ms(base_event->timestamp_us() / 1000);
+ proto_batch->set_remote_ssrc(base_event->config().remote_ssrc);
+ proto_batch->set_local_ssrc(base_event->config().local_ssrc);
+ proto_batch->set_rtx_ssrc(base_event->config().rtx_ssrc);
+ if (!base_event->config().rsid.empty())
+ proto_batch->set_rsid(base_event->config().rsid);
rtclog2::RtpHeaderExtensionConfig* proto_config =
proto_batch->mutable_header_extensions();
bool has_recognized_extensions =
- ConvertToProtoFormat(base_event->config_->rtp_extensions, proto_config);
+ ConvertToProtoFormat(base_event->config().rtp_extensions, proto_config);
if (!has_recognized_extensions)
proto_batch->clear_header_extensions();
}
@@ -1257,16 +1258,16 @@
for (const RtcEventVideoSendStreamConfig* base_event : batch) {
rtclog2::VideoSendStreamConfig* proto_batch =
event_stream->add_video_send_stream_configs();
- proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
- proto_batch->set_ssrc(base_event->config_->local_ssrc);
- proto_batch->set_rtx_ssrc(base_event->config_->rtx_ssrc);
- if (!base_event->config_->rsid.empty())
- proto_batch->set_rsid(base_event->config_->rsid);
+ proto_batch->set_timestamp_ms(base_event->timestamp_us() / 1000);
+ proto_batch->set_ssrc(base_event->config().local_ssrc);
+ proto_batch->set_rtx_ssrc(base_event->config().rtx_ssrc);
+ if (!base_event->config().rsid.empty())
+ proto_batch->set_rsid(base_event->config().rsid);
rtclog2::RtpHeaderExtensionConfig* proto_config =
proto_batch->mutable_header_extensions();
bool has_recognized_extensions =
- ConvertToProtoFormat(base_event->config_->rtp_extensions, proto_config);
+ ConvertToProtoFormat(base_event->config().rtp_extensions, proto_config);
if (!has_recognized_extensions)
proto_batch->clear_header_extensions();
}
@@ -1279,10 +1280,10 @@
rtclog2::IceCandidatePairConfig* proto_batch =
event_stream->add_ice_candidate_configs();
- proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
- proto_batch->set_config_type(ConvertToProtoFormat(base_event->type_));
- proto_batch->set_candidate_pair_id(base_event->candidate_pair_id_);
- const auto& desc = base_event->candidate_pair_desc_;
+ proto_batch->set_timestamp_ms(base_event->timestamp_us() / 1000);
+ proto_batch->set_config_type(ConvertToProtoFormat(base_event->type()));
+ proto_batch->set_candidate_pair_id(base_event->candidate_pair_id());
+ const auto& desc = base_event->candidate_pair_desc();
proto_batch->set_local_candidate_type(
ConvertToProtoFormat(desc.local_candidate_type));
proto_batch->set_local_relay_protocol(
@@ -1308,10 +1309,10 @@
rtclog2::IceCandidatePairEvent* proto_batch =
event_stream->add_ice_candidate_events();
- proto_batch->set_timestamp_ms(base_event->timestamp_us_ / 1000);
+ proto_batch->set_timestamp_ms(base_event->timestamp_us() / 1000);
- proto_batch->set_event_type(ConvertToProtoFormat(base_event->type_));
- proto_batch->set_candidate_pair_id(base_event->candidate_pair_id_);
+ proto_batch->set_event_type(ConvertToProtoFormat(base_event->type()));
+ proto_batch->set_candidate_pair_id(base_event->candidate_pair_id());
}
// TODO(terelius): Should we delta-compress this event type?
}
diff --git a/logging/rtc_event_log/events/rtc_event.h b/logging/rtc_event_log/events/rtc_event.h
index 5e6a4a2..cecde32 100644
--- a/logging/rtc_event_log/events/rtc_event.h
+++ b/logging/rtc_event_log/events/rtc_event.h
@@ -57,10 +57,14 @@
virtual bool IsConfigEvent() const = 0;
- const int64_t timestamp_us_;
+ int64_t timestamp_us() const { return timestamp_us_; }
+
+ // TODO(eladalon): Add timestamp_ms().
protected:
explicit RtcEvent(int64_t timestamp_us) : timestamp_us_(timestamp_us) {}
+
+ const int64_t timestamp_us_;
};
} // namespace webrtc
diff --git a/logging/rtc_event_log/events/rtc_event_alr_state.h b/logging/rtc_event_log/events/rtc_event_alr_state.h
index 5749e10..9769585 100644
--- a/logging/rtc_event_log/events/rtc_event_alr_state.h
+++ b/logging/rtc_event_log/events/rtc_event_alr_state.h
@@ -28,10 +28,12 @@
std::unique_ptr<RtcEventAlrState> Copy() const;
- const bool in_alr_;
+ bool in_alr() const { return in_alr_; }
private:
RtcEventAlrState(const RtcEventAlrState& other);
+
+ const bool in_alr_;
};
} // namespace webrtc
diff --git a/logging/rtc_event_log/events/rtc_event_audio_network_adaptation.cc b/logging/rtc_event_log/events/rtc_event_audio_network_adaptation.cc
index c51be77..571b9a9 100644
--- a/logging/rtc_event_log/events/rtc_event_audio_network_adaptation.cc
+++ b/logging/rtc_event_log/events/rtc_event_audio_network_adaptation.cc
@@ -14,12 +14,15 @@
#include "absl/memory/memory.h"
#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h"
+#include "rtc_base/checks.h"
namespace webrtc {
RtcEventAudioNetworkAdaptation::RtcEventAudioNetworkAdaptation(
std::unique_ptr<AudioEncoderRuntimeConfig> config)
- : config_(std::move(config)) {}
+ : config_(std::move(config)) {
+ RTC_DCHECK(config_);
+}
RtcEventAudioNetworkAdaptation::RtcEventAudioNetworkAdaptation(
const RtcEventAudioNetworkAdaptation& other)
diff --git a/logging/rtc_event_log/events/rtc_event_audio_network_adaptation.h b/logging/rtc_event_log/events/rtc_event_audio_network_adaptation.h
index 08c6026..ec6ca11 100644
--- a/logging/rtc_event_log/events/rtc_event_audio_network_adaptation.h
+++ b/logging/rtc_event_log/events/rtc_event_audio_network_adaptation.h
@@ -31,10 +31,12 @@
std::unique_ptr<RtcEventAudioNetworkAdaptation> Copy() const;
- const std::unique_ptr<const AudioEncoderRuntimeConfig> config_;
+ const AudioEncoderRuntimeConfig& config() const { return *config_; }
private:
RtcEventAudioNetworkAdaptation(const RtcEventAudioNetworkAdaptation& other);
+
+ const std::unique_ptr<const AudioEncoderRuntimeConfig> config_;
};
} // namespace webrtc
diff --git a/logging/rtc_event_log/events/rtc_event_audio_playout.h b/logging/rtc_event_log/events/rtc_event_audio_playout.h
index 068e91e..4b40f5c 100644
--- a/logging/rtc_event_log/events/rtc_event_audio_playout.h
+++ b/logging/rtc_event_log/events/rtc_event_audio_playout.h
@@ -29,10 +29,12 @@
std::unique_ptr<RtcEventAudioPlayout> Copy() const;
- const uint32_t ssrc_;
+ uint32_t ssrc() const { return ssrc_; }
private:
RtcEventAudioPlayout(const RtcEventAudioPlayout& other);
+
+ const uint32_t ssrc_;
};
} // namespace webrtc
diff --git a/logging/rtc_event_log/events/rtc_event_audio_receive_stream_config.cc b/logging/rtc_event_log/events/rtc_event_audio_receive_stream_config.cc
index 7f78a39..50d67ff 100644
--- a/logging/rtc_event_log/events/rtc_event_audio_receive_stream_config.cc
+++ b/logging/rtc_event_log/events/rtc_event_audio_receive_stream_config.cc
@@ -14,12 +14,15 @@
#include "absl/memory/memory.h"
#include "logging/rtc_event_log/rtc_stream_config.h"
+#include "rtc_base/checks.h"
namespace webrtc {
RtcEventAudioReceiveStreamConfig::RtcEventAudioReceiveStreamConfig(
std::unique_ptr<rtclog::StreamConfig> config)
- : config_(std::move(config)) {}
+ : config_(std::move(config)) {
+ RTC_DCHECK(config_);
+}
RtcEventAudioReceiveStreamConfig::RtcEventAudioReceiveStreamConfig(
const RtcEventAudioReceiveStreamConfig& other)
diff --git a/logging/rtc_event_log/events/rtc_event_audio_receive_stream_config.h b/logging/rtc_event_log/events/rtc_event_audio_receive_stream_config.h
index 098f10b..2b73f63 100644
--- a/logging/rtc_event_log/events/rtc_event_audio_receive_stream_config.h
+++ b/logging/rtc_event_log/events/rtc_event_audio_receive_stream_config.h
@@ -33,11 +33,13 @@
std::unique_ptr<RtcEventAudioReceiveStreamConfig> Copy() const;
- const std::unique_ptr<const rtclog::StreamConfig> config_;
+ const rtclog::StreamConfig& config() const { return *config_; }
private:
RtcEventAudioReceiveStreamConfig(
const RtcEventAudioReceiveStreamConfig& other);
+
+ const std::unique_ptr<const rtclog::StreamConfig> config_;
};
} // namespace webrtc
diff --git a/logging/rtc_event_log/events/rtc_event_audio_send_stream_config.cc b/logging/rtc_event_log/events/rtc_event_audio_send_stream_config.cc
index 83dbe74..240e831 100644
--- a/logging/rtc_event_log/events/rtc_event_audio_send_stream_config.cc
+++ b/logging/rtc_event_log/events/rtc_event_audio_send_stream_config.cc
@@ -14,12 +14,15 @@
#include "absl/memory/memory.h"
#include "logging/rtc_event_log/rtc_stream_config.h"
+#include "rtc_base/checks.h"
namespace webrtc {
RtcEventAudioSendStreamConfig::RtcEventAudioSendStreamConfig(
std::unique_ptr<rtclog::StreamConfig> config)
- : config_(std::move(config)) {}
+ : config_(std::move(config)) {
+ RTC_DCHECK(config_);
+}
RtcEventAudioSendStreamConfig::RtcEventAudioSendStreamConfig(
const RtcEventAudioSendStreamConfig& other)
diff --git a/logging/rtc_event_log/events/rtc_event_audio_send_stream_config.h b/logging/rtc_event_log/events/rtc_event_audio_send_stream_config.h
index a0758a3..c0efa95 100644
--- a/logging/rtc_event_log/events/rtc_event_audio_send_stream_config.h
+++ b/logging/rtc_event_log/events/rtc_event_audio_send_stream_config.h
@@ -33,10 +33,12 @@
std::unique_ptr<RtcEventAudioSendStreamConfig> Copy() const;
- const std::unique_ptr<const rtclog::StreamConfig> config_;
+ const rtclog::StreamConfig& config() const { return *config_; }
private:
RtcEventAudioSendStreamConfig(const RtcEventAudioSendStreamConfig& other);
+
+ const std::unique_ptr<const rtclog::StreamConfig> config_;
};
} // namespace webrtc
diff --git a/logging/rtc_event_log/events/rtc_event_bwe_update_delay_based.h b/logging/rtc_event_log/events/rtc_event_bwe_update_delay_based.h
index 3919a51..a97d49f 100644
--- a/logging/rtc_event_log/events/rtc_event_bwe_update_delay_based.h
+++ b/logging/rtc_event_log/events/rtc_event_bwe_update_delay_based.h
@@ -32,11 +32,14 @@
std::unique_ptr<RtcEventBweUpdateDelayBased> Copy() const;
- const int32_t bitrate_bps_;
- const BandwidthUsage detector_state_;
+ int32_t bitrate_bps() const { return bitrate_bps_; }
+ BandwidthUsage detector_state() const { return detector_state_; }
private:
RtcEventBweUpdateDelayBased(const RtcEventBweUpdateDelayBased& other);
+
+ const int32_t bitrate_bps_;
+ const BandwidthUsage detector_state_;
};
} // namespace webrtc
diff --git a/logging/rtc_event_log/events/rtc_event_bwe_update_loss_based.h b/logging/rtc_event_log/events/rtc_event_bwe_update_loss_based.h
index 49f04d1..b4f8877 100644
--- a/logging/rtc_event_log/events/rtc_event_bwe_update_loss_based.h
+++ b/logging/rtc_event_log/events/rtc_event_bwe_update_loss_based.h
@@ -31,12 +31,16 @@
std::unique_ptr<RtcEventBweUpdateLossBased> Copy() const;
- const int32_t bitrate_bps_;
- const uint8_t fraction_loss_;
- const int32_t total_packets_;
+ int32_t bitrate_bps() const { return bitrate_bps_; }
+ uint8_t fraction_loss() const { return fraction_loss_; }
+ int32_t total_packets() const { return total_packets_; }
private:
RtcEventBweUpdateLossBased(const RtcEventBweUpdateLossBased& other);
+
+ const int32_t bitrate_bps_;
+ const uint8_t fraction_loss_;
+ const int32_t total_packets_;
};
} // namespace webrtc
diff --git a/logging/rtc_event_log/events/rtc_event_ice_candidate_pair.h b/logging/rtc_event_log/events/rtc_event_ice_candidate_pair.h
index e031804..7414fec 100644
--- a/logging/rtc_event_log/events/rtc_event_ice_candidate_pair.h
+++ b/logging/rtc_event_log/events/rtc_event_ice_candidate_pair.h
@@ -38,11 +38,14 @@
std::unique_ptr<RtcEventIceCandidatePair> Copy() const;
- const IceCandidatePairEventType type_;
- const uint32_t candidate_pair_id_;
+ IceCandidatePairEventType type() const { return type_; }
+ uint32_t candidate_pair_id() const { return candidate_pair_id_; }
private:
RtcEventIceCandidatePair(const RtcEventIceCandidatePair& other);
+
+ const IceCandidatePairEventType type_;
+ const uint32_t candidate_pair_id_;
};
} // namespace webrtc
diff --git a/logging/rtc_event_log/events/rtc_event_ice_candidate_pair_config.h b/logging/rtc_event_log/events/rtc_event_ice_candidate_pair_config.h
index 6b6eb50..40bdbaa 100644
--- a/logging/rtc_event_log/events/rtc_event_ice_candidate_pair_config.h
+++ b/logging/rtc_event_log/events/rtc_event_ice_candidate_pair_config.h
@@ -94,12 +94,18 @@
std::unique_ptr<RtcEventIceCandidatePairConfig> Copy() const;
- const IceCandidatePairConfigType type_;
- const uint32_t candidate_pair_id_;
- const IceCandidatePairDescription candidate_pair_desc_;
+ IceCandidatePairConfigType type() const { return type_; }
+ uint32_t candidate_pair_id() const { return candidate_pair_id_; }
+ const IceCandidatePairDescription& candidate_pair_desc() const {
+ return candidate_pair_desc_;
+ }
private:
RtcEventIceCandidatePairConfig(const RtcEventIceCandidatePairConfig& other);
+
+ const IceCandidatePairConfigType type_;
+ const uint32_t candidate_pair_id_;
+ const IceCandidatePairDescription candidate_pair_desc_;
};
} // namespace webrtc
diff --git a/logging/rtc_event_log/events/rtc_event_probe_cluster_created.h b/logging/rtc_event_log/events/rtc_event_probe_cluster_created.h
index c1bdabc..ad757ed 100644
--- a/logging/rtc_event_log/events/rtc_event_probe_cluster_created.h
+++ b/logging/rtc_event_log/events/rtc_event_probe_cluster_created.h
@@ -32,13 +32,18 @@
std::unique_ptr<RtcEventProbeClusterCreated> Copy() const;
+ int32_t id() const { return id_; }
+ int32_t bitrate_bps() const { return bitrate_bps_; }
+ uint32_t min_probes() const { return min_probes_; }
+ uint32_t min_bytes() const { return min_bytes_; }
+
+ private:
+ RtcEventProbeClusterCreated(const RtcEventProbeClusterCreated& other);
+
const int32_t id_;
const int32_t bitrate_bps_;
const uint32_t min_probes_;
const uint32_t min_bytes_;
-
- private:
- RtcEventProbeClusterCreated(const RtcEventProbeClusterCreated& other);
};
} // namespace webrtc
diff --git a/logging/rtc_event_log/events/rtc_event_probe_result_failure.h b/logging/rtc_event_log/events/rtc_event_probe_result_failure.h
index fe45501..0c40f0c 100644
--- a/logging/rtc_event_log/events/rtc_event_probe_result_failure.h
+++ b/logging/rtc_event_log/events/rtc_event_probe_result_failure.h
@@ -36,11 +36,14 @@
std::unique_ptr<RtcEventProbeResultFailure> Copy() const;
- const int32_t id_;
- const ProbeFailureReason failure_reason_;
+ int32_t id() const { return id_; }
+ ProbeFailureReason failure_reason() const { return failure_reason_; }
private:
RtcEventProbeResultFailure(const RtcEventProbeResultFailure& other);
+
+ const int32_t id_;
+ const ProbeFailureReason failure_reason_;
};
} // namespace webrtc
diff --git a/logging/rtc_event_log/events/rtc_event_probe_result_success.h b/logging/rtc_event_log/events/rtc_event_probe_result_success.h
index 783e20a..a08dadd 100644
--- a/logging/rtc_event_log/events/rtc_event_probe_result_success.h
+++ b/logging/rtc_event_log/events/rtc_event_probe_result_success.h
@@ -29,11 +29,14 @@
std::unique_ptr<RtcEventProbeResultSuccess> Copy() const;
- const int32_t id_;
- const int32_t bitrate_bps_;
+ int32_t id() const { return id_; }
+ int32_t bitrate_bps() const { return bitrate_bps_; }
private:
RtcEventProbeResultSuccess(const RtcEventProbeResultSuccess& other);
+
+ const int32_t id_;
+ const int32_t bitrate_bps_;
};
} // namespace webrtc
diff --git a/logging/rtc_event_log/events/rtc_event_rtcp_packet_incoming.h b/logging/rtc_event_log/events/rtc_event_rtcp_packet_incoming.h
index ffe9830..8394fe0 100644
--- a/logging/rtc_event_log/events/rtc_event_rtcp_packet_incoming.h
+++ b/logging/rtc_event_log/events/rtc_event_rtcp_packet_incoming.h
@@ -31,10 +31,12 @@
std::unique_ptr<RtcEventRtcpPacketIncoming> Copy() const;
- rtc::Buffer packet_;
+ const rtc::Buffer& packet() const { return packet_; }
private:
RtcEventRtcpPacketIncoming(const RtcEventRtcpPacketIncoming& other);
+
+ rtc::Buffer packet_;
};
} // namespace webrtc
diff --git a/logging/rtc_event_log/events/rtc_event_rtcp_packet_outgoing.h b/logging/rtc_event_log/events/rtc_event_rtcp_packet_outgoing.h
index 42df64b..b47b85d 100644
--- a/logging/rtc_event_log/events/rtc_event_rtcp_packet_outgoing.h
+++ b/logging/rtc_event_log/events/rtc_event_rtcp_packet_outgoing.h
@@ -31,10 +31,12 @@
std::unique_ptr<RtcEventRtcpPacketOutgoing> Copy() const;
- rtc::Buffer packet_;
+ const rtc::Buffer& packet() const { return packet_; }
private:
RtcEventRtcpPacketOutgoing(const RtcEventRtcpPacketOutgoing& other);
+
+ rtc::Buffer packet_;
};
} // namespace webrtc
diff --git a/logging/rtc_event_log/events/rtc_event_rtp_packet_incoming.cc b/logging/rtc_event_log/events/rtc_event_rtp_packet_incoming.cc
index 54cf1e3..898c0aa 100644
--- a/logging/rtc_event_log/events/rtc_event_rtp_packet_incoming.cc
+++ b/logging/rtc_event_log/events/rtc_event_rtp_packet_incoming.cc
@@ -12,6 +12,7 @@
#include "absl/memory/memory.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
+#include "rtc_base/checks.h"
namespace webrtc {
diff --git a/logging/rtc_event_log/events/rtc_event_rtp_packet_incoming.h b/logging/rtc_event_log/events/rtc_event_rtp_packet_incoming.h
index bc622de..1e35735 100644
--- a/logging/rtc_event_log/events/rtc_event_rtp_packet_incoming.h
+++ b/logging/rtc_event_log/events/rtc_event_rtp_packet_incoming.h
@@ -35,13 +35,18 @@
return payload_length_ + header_length_ + padding_length_;
}
+ const RtpPacket& header() const { return header_; }
+ size_t payload_length() const { return payload_length_; }
+ size_t header_length() const { return header_length_; }
+ size_t padding_length() const { return padding_length_; }
+
+ private:
+ RtcEventRtpPacketIncoming(const RtcEventRtpPacketIncoming& other);
+
RtpPacket header_; // Only the packet's header will be stored here.
const size_t payload_length_; // Media payload, excluding header and padding.
const size_t header_length_; // RTP header.
const size_t padding_length_; // RTP padding.
-
- private:
- RtcEventRtpPacketIncoming(const RtcEventRtpPacketIncoming& other);
};
} // namespace webrtc
diff --git a/logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.cc b/logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.cc
index 9c77d55..050474e 100644
--- a/logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.cc
+++ b/logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.cc
@@ -12,6 +12,7 @@
#include "absl/memory/memory.h"
#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
+#include "rtc_base/checks.h"
namespace webrtc {
diff --git a/logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h b/logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h
index ecb678e..ebddc14 100644
--- a/logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h
+++ b/logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h
@@ -36,14 +36,21 @@
return payload_length_ + header_length_ + padding_length_;
}
+ const RtpPacket& header() const { return header_; }
+ size_t payload_length() const { return payload_length_; }
+ size_t header_length() const { return header_length_; }
+ size_t padding_length() const { return padding_length_; }
+ int probe_cluster_id() const { return probe_cluster_id_; }
+
+ private:
+ RtcEventRtpPacketOutgoing(const RtcEventRtpPacketOutgoing& other);
+
RtpPacket header_; // Only the packet's header will be stored here.
const size_t payload_length_; // Media payload, excluding header and padding.
const size_t header_length_; // RTP header.
const size_t padding_length_; // RTP padding.
+ // TODO(eladalon): Delete |probe_cluster_id_| along with legacy encoding.
const int probe_cluster_id_;
-
- private:
- RtcEventRtpPacketOutgoing(const RtcEventRtpPacketOutgoing& other);
};
} // namespace webrtc
diff --git a/logging/rtc_event_log/events/rtc_event_video_receive_stream_config.cc b/logging/rtc_event_log/events/rtc_event_video_receive_stream_config.cc
index 97d94a3..5dec97b 100644
--- a/logging/rtc_event_log/events/rtc_event_video_receive_stream_config.cc
+++ b/logging/rtc_event_log/events/rtc_event_video_receive_stream_config.cc
@@ -13,12 +13,15 @@
#include <utility>
#include "absl/memory/memory.h"
+#include "rtc_base/checks.h"
namespace webrtc {
RtcEventVideoReceiveStreamConfig::RtcEventVideoReceiveStreamConfig(
std::unique_ptr<rtclog::StreamConfig> config)
- : config_(std::move(config)) {}
+ : config_(std::move(config)) {
+ RTC_DCHECK(config_);
+}
RtcEventVideoReceiveStreamConfig::RtcEventVideoReceiveStreamConfig(
const RtcEventVideoReceiveStreamConfig& other)
diff --git a/logging/rtc_event_log/events/rtc_event_video_receive_stream_config.h b/logging/rtc_event_log/events/rtc_event_video_receive_stream_config.h
index 4879691..801ba7d 100644
--- a/logging/rtc_event_log/events/rtc_event_video_receive_stream_config.h
+++ b/logging/rtc_event_log/events/rtc_event_video_receive_stream_config.h
@@ -30,11 +30,13 @@
std::unique_ptr<RtcEventVideoReceiveStreamConfig> Copy() const;
- const std::unique_ptr<const rtclog::StreamConfig> config_;
+ const rtclog::StreamConfig& config() const { return *config_; }
private:
RtcEventVideoReceiveStreamConfig(
const RtcEventVideoReceiveStreamConfig& other);
+
+ const std::unique_ptr<const rtclog::StreamConfig> config_;
};
} // namespace webrtc
diff --git a/logging/rtc_event_log/events/rtc_event_video_send_stream_config.h b/logging/rtc_event_log/events/rtc_event_video_send_stream_config.h
index 22c89ef..fe274c8 100644
--- a/logging/rtc_event_log/events/rtc_event_video_send_stream_config.h
+++ b/logging/rtc_event_log/events/rtc_event_video_send_stream_config.h
@@ -30,10 +30,12 @@
std::unique_ptr<RtcEventVideoSendStreamConfig> Copy() const;
- const std::unique_ptr<const rtclog::StreamConfig> config_;
+ const rtclog::StreamConfig& config() const { return *config_; }
private:
RtcEventVideoSendStreamConfig(const RtcEventVideoSendStreamConfig& other);
+
+ const std::unique_ptr<const rtclog::StreamConfig> config_;
};
} // namespace webrtc
diff --git a/logging/rtc_event_log/rtc_event_log_unittest_helper.cc b/logging/rtc_event_log/rtc_event_log_unittest_helper.cc
index 9782107..a5834fa 100644
--- a/logging/rtc_event_log/rtc_event_log_unittest_helper.cc
+++ b/logging/rtc_event_log/rtc_event_log_unittest_helper.cc
@@ -503,37 +503,37 @@
void VerifyLoggedAlrStateEvent(const RtcEventAlrState& original_event,
const LoggedAlrStateEvent& logged_event) {
- EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
- EXPECT_EQ(original_event.in_alr_, logged_event.in_alr);
+ EXPECT_EQ(original_event.timestamp_us() / 1000, logged_event.log_time_ms());
+ EXPECT_EQ(original_event.in_alr(), logged_event.in_alr);
}
void VerifyLoggedAudioPlayoutEvent(
const RtcEventAudioPlayout& original_event,
const LoggedAudioPlayoutEvent& logged_event) {
- EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
- EXPECT_EQ(original_event.ssrc_, logged_event.ssrc);
+ EXPECT_EQ(original_event.timestamp_us() / 1000, logged_event.log_time_ms());
+ EXPECT_EQ(original_event.ssrc(), logged_event.ssrc);
}
void VerifyLoggedAudioNetworkAdaptationEvent(
const RtcEventAudioNetworkAdaptation& original_event,
const LoggedAudioNetworkAdaptationEvent& logged_event) {
- EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
+ EXPECT_EQ(original_event.timestamp_us() / 1000, logged_event.log_time_ms());
- EXPECT_EQ(original_event.config_->bitrate_bps,
+ EXPECT_EQ(original_event.config().bitrate_bps,
logged_event.config.bitrate_bps);
- EXPECT_EQ(original_event.config_->enable_dtx, logged_event.config.enable_dtx);
- EXPECT_EQ(original_event.config_->enable_fec, logged_event.config.enable_fec);
- EXPECT_EQ(original_event.config_->frame_length_ms,
+ EXPECT_EQ(original_event.config().enable_dtx, logged_event.config.enable_dtx);
+ EXPECT_EQ(original_event.config().enable_fec, logged_event.config.enable_fec);
+ EXPECT_EQ(original_event.config().frame_length_ms,
logged_event.config.frame_length_ms);
- EXPECT_EQ(original_event.config_->num_channels,
+ EXPECT_EQ(original_event.config().num_channels,
logged_event.config.num_channels);
// uplink_packet_loss_fraction
- ASSERT_EQ(original_event.config_->uplink_packet_loss_fraction.has_value(),
+ ASSERT_EQ(original_event.config().uplink_packet_loss_fraction.has_value(),
logged_event.config.uplink_packet_loss_fraction.has_value());
- if (original_event.config_->uplink_packet_loss_fraction.has_value()) {
+ if (original_event.config().uplink_packet_loss_fraction.has_value()) {
const float original =
- original_event.config_->uplink_packet_loss_fraction.value();
+ original_event.config().uplink_packet_loss_fraction.value();
const float logged =
logged_event.config.uplink_packet_loss_fraction.value();
const float uplink_packet_loss_fraction_delta = std::abs(original - logged);
@@ -544,76 +544,76 @@
void VerifyLoggedBweDelayBasedUpdate(
const RtcEventBweUpdateDelayBased& original_event,
const LoggedBweDelayBasedUpdate& logged_event) {
- EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
- EXPECT_EQ(original_event.bitrate_bps_, logged_event.bitrate_bps);
- EXPECT_EQ(original_event.detector_state_, logged_event.detector_state);
+ EXPECT_EQ(original_event.timestamp_us() / 1000, logged_event.log_time_ms());
+ EXPECT_EQ(original_event.bitrate_bps(), logged_event.bitrate_bps);
+ EXPECT_EQ(original_event.detector_state(), logged_event.detector_state);
}
void VerifyLoggedBweLossBasedUpdate(
const RtcEventBweUpdateLossBased& original_event,
const LoggedBweLossBasedUpdate& logged_event) {
- EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
- EXPECT_EQ(original_event.bitrate_bps_, logged_event.bitrate_bps);
- EXPECT_EQ(original_event.fraction_loss_, logged_event.fraction_lost);
- EXPECT_EQ(original_event.total_packets_, logged_event.expected_packets);
+ EXPECT_EQ(original_event.timestamp_us() / 1000, logged_event.log_time_ms());
+ EXPECT_EQ(original_event.bitrate_bps(), logged_event.bitrate_bps);
+ EXPECT_EQ(original_event.fraction_loss(), logged_event.fraction_lost);
+ EXPECT_EQ(original_event.total_packets(), logged_event.expected_packets);
}
void VerifyLoggedBweProbeClusterCreatedEvent(
const RtcEventProbeClusterCreated& original_event,
const LoggedBweProbeClusterCreatedEvent& logged_event) {
- EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
- EXPECT_EQ(original_event.id_, logged_event.id);
- EXPECT_EQ(original_event.bitrate_bps_, logged_event.bitrate_bps);
- EXPECT_EQ(original_event.min_probes_, logged_event.min_packets);
- EXPECT_EQ(original_event.min_bytes_, logged_event.min_bytes);
+ EXPECT_EQ(original_event.timestamp_us() / 1000, logged_event.log_time_ms());
+ EXPECT_EQ(original_event.id(), logged_event.id);
+ EXPECT_EQ(original_event.bitrate_bps(), logged_event.bitrate_bps);
+ EXPECT_EQ(original_event.min_probes(), logged_event.min_packets);
+ EXPECT_EQ(original_event.min_bytes(), logged_event.min_bytes);
}
void VerifyLoggedBweProbeFailureEvent(
const RtcEventProbeResultFailure& original_event,
const LoggedBweProbeFailureEvent& logged_event) {
- EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
- EXPECT_EQ(original_event.id_, logged_event.id);
- EXPECT_EQ(original_event.failure_reason_, logged_event.failure_reason);
+ EXPECT_EQ(original_event.timestamp_us() / 1000, logged_event.log_time_ms());
+ EXPECT_EQ(original_event.id(), logged_event.id);
+ EXPECT_EQ(original_event.failure_reason(), logged_event.failure_reason);
}
void VerifyLoggedBweProbeSuccessEvent(
const RtcEventProbeResultSuccess& original_event,
const LoggedBweProbeSuccessEvent& logged_event) {
- EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
- EXPECT_EQ(original_event.id_, logged_event.id);
- EXPECT_EQ(original_event.bitrate_bps_, logged_event.bitrate_bps);
+ EXPECT_EQ(original_event.timestamp_us() / 1000, logged_event.log_time_ms());
+ EXPECT_EQ(original_event.id(), logged_event.id);
+ EXPECT_EQ(original_event.bitrate_bps(), logged_event.bitrate_bps);
}
void VerifyLoggedIceCandidatePairConfig(
const RtcEventIceCandidatePairConfig& original_event,
const LoggedIceCandidatePairConfig& logged_event) {
- EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
+ EXPECT_EQ(original_event.timestamp_us() / 1000, logged_event.log_time_ms());
- EXPECT_EQ(original_event.type_, logged_event.type);
- EXPECT_EQ(original_event.candidate_pair_id_, logged_event.candidate_pair_id);
- EXPECT_EQ(original_event.candidate_pair_desc_.local_candidate_type,
+ EXPECT_EQ(original_event.type(), logged_event.type);
+ EXPECT_EQ(original_event.candidate_pair_id(), logged_event.candidate_pair_id);
+ EXPECT_EQ(original_event.candidate_pair_desc().local_candidate_type,
logged_event.local_candidate_type);
- EXPECT_EQ(original_event.candidate_pair_desc_.local_relay_protocol,
+ EXPECT_EQ(original_event.candidate_pair_desc().local_relay_protocol,
logged_event.local_relay_protocol);
- EXPECT_EQ(original_event.candidate_pair_desc_.local_network_type,
+ EXPECT_EQ(original_event.candidate_pair_desc().local_network_type,
logged_event.local_network_type);
- EXPECT_EQ(original_event.candidate_pair_desc_.local_address_family,
+ EXPECT_EQ(original_event.candidate_pair_desc().local_address_family,
logged_event.local_address_family);
- EXPECT_EQ(original_event.candidate_pair_desc_.remote_candidate_type,
+ EXPECT_EQ(original_event.candidate_pair_desc().remote_candidate_type,
logged_event.remote_candidate_type);
- EXPECT_EQ(original_event.candidate_pair_desc_.remote_address_family,
+ EXPECT_EQ(original_event.candidate_pair_desc().remote_address_family,
logged_event.remote_address_family);
- EXPECT_EQ(original_event.candidate_pair_desc_.candidate_pair_protocol,
+ EXPECT_EQ(original_event.candidate_pair_desc().candidate_pair_protocol,
logged_event.candidate_pair_protocol);
}
void VerifyLoggedIceCandidatePairEvent(
const RtcEventIceCandidatePair& original_event,
const LoggedIceCandidatePairEvent& logged_event) {
- EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
+ EXPECT_EQ(original_event.timestamp_us() / 1000, logged_event.log_time_ms());
- EXPECT_EQ(original_event.type_, logged_event.type);
- EXPECT_EQ(original_event.candidate_pair_id_, logged_event.candidate_pair_id);
+ EXPECT_EQ(original_event.type(), logged_event.type);
+ EXPECT_EQ(original_event.candidate_pair_id(), logged_event.candidate_pair_id);
}
void VerifyLoggedRtpHeader(const RtpPacket& original_header,
@@ -680,63 +680,63 @@
void VerifyLoggedRtpPacketIncoming(
const RtcEventRtpPacketIncoming& original_event,
const LoggedRtpPacketIncoming& logged_event) {
- EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
+ EXPECT_EQ(original_event.timestamp_us() / 1000, logged_event.log_time_ms());
- EXPECT_EQ(original_event.header_.headers_size(),
+ EXPECT_EQ(original_event.header().headers_size(),
logged_event.rtp.header_length);
EXPECT_EQ(original_event.packet_length(), logged_event.rtp.total_length);
// Currently, RTC eventlog encoder-parser can only maintain padding length
// if packet is full padding.
- EXPECT_EQ(original_event.padding_length_,
+ EXPECT_EQ(original_event.padding_length(),
logged_event.rtp.header.paddingLength);
- VerifyLoggedRtpHeader(original_event.header_, logged_event.rtp.header);
+ VerifyLoggedRtpHeader(original_event.header(), logged_event.rtp.header);
}
void VerifyLoggedRtpPacketOutgoing(
const RtcEventRtpPacketOutgoing& original_event,
const LoggedRtpPacketOutgoing& logged_event) {
- EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
+ EXPECT_EQ(original_event.timestamp_us() / 1000, logged_event.log_time_ms());
- EXPECT_EQ(original_event.header_.headers_size(),
+ EXPECT_EQ(original_event.header().headers_size(),
logged_event.rtp.header_length);
EXPECT_EQ(original_event.packet_length(), logged_event.rtp.total_length);
// Currently, RTC eventlog encoder-parser can only maintain padding length
// if packet is full padding.
- EXPECT_EQ(original_event.padding_length_,
+ EXPECT_EQ(original_event.padding_length(),
logged_event.rtp.header.paddingLength);
// TODO(terelius): Probe cluster ID isn't parsed, used or tested. Unless
// someone has a strong reason to keep it, it'll be removed.
- VerifyLoggedRtpHeader(original_event.header_, logged_event.rtp.header);
+ VerifyLoggedRtpHeader(original_event.header(), logged_event.rtp.header);
}
void VerifyLoggedRtcpPacketIncoming(
const RtcEventRtcpPacketIncoming& original_event,
const LoggedRtcpPacketIncoming& logged_event) {
- EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
+ EXPECT_EQ(original_event.timestamp_us() / 1000, logged_event.log_time_ms());
- ASSERT_EQ(original_event.packet_.size(), logged_event.rtcp.raw_data.size());
+ ASSERT_EQ(original_event.packet().size(), logged_event.rtcp.raw_data.size());
EXPECT_EQ(
- memcmp(original_event.packet_.data(), logged_event.rtcp.raw_data.data(),
- original_event.packet_.size()),
+ memcmp(original_event.packet().data(), logged_event.rtcp.raw_data.data(),
+ original_event.packet().size()),
0);
}
void VerifyLoggedRtcpPacketOutgoing(
const RtcEventRtcpPacketOutgoing& original_event,
const LoggedRtcpPacketOutgoing& logged_event) {
- EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
+ EXPECT_EQ(original_event.timestamp_us() / 1000, logged_event.log_time_ms());
- ASSERT_EQ(original_event.packet_.size(), logged_event.rtcp.raw_data.size());
+ ASSERT_EQ(original_event.packet().size(), logged_event.rtcp.raw_data.size());
EXPECT_EQ(
- memcmp(original_event.packet_.data(), logged_event.rtcp.raw_data.data(),
- original_event.packet_.size()),
+ memcmp(original_event.packet().data(), logged_event.rtcp.raw_data.data(),
+ original_event.packet().size()),
0);
}
@@ -779,33 +779,33 @@
void VerifyLoggedAudioRecvConfig(
const RtcEventAudioReceiveStreamConfig& original_event,
const LoggedAudioRecvConfig& logged_event) {
- EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
- VerifyLoggedStreamConfig(*original_event.config_, logged_event.config);
+ EXPECT_EQ(original_event.timestamp_us() / 1000, logged_event.log_time_ms());
+ VerifyLoggedStreamConfig(original_event.config(), logged_event.config);
}
void VerifyLoggedAudioSendConfig(
const RtcEventAudioSendStreamConfig& original_event,
const LoggedAudioSendConfig& logged_event) {
- EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
- VerifyLoggedStreamConfig(*original_event.config_, logged_event.config);
+ EXPECT_EQ(original_event.timestamp_us() / 1000, logged_event.log_time_ms());
+ VerifyLoggedStreamConfig(original_event.config(), logged_event.config);
}
void VerifyLoggedVideoRecvConfig(
const RtcEventVideoReceiveStreamConfig& original_event,
const LoggedVideoRecvConfig& logged_event) {
- EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
- VerifyLoggedStreamConfig(*original_event.config_, logged_event.config);
+ EXPECT_EQ(original_event.timestamp_us() / 1000, logged_event.log_time_ms());
+ VerifyLoggedStreamConfig(original_event.config(), logged_event.config);
}
void VerifyLoggedVideoSendConfig(
const RtcEventVideoSendStreamConfig& original_event,
const LoggedVideoSendConfig& logged_event) {
- EXPECT_EQ(original_event.timestamp_us_ / 1000, logged_event.log_time_ms());
+ EXPECT_EQ(original_event.timestamp_us() / 1000, logged_event.log_time_ms());
// TODO(terelius): In the past, we allowed storing multiple RtcStreamConfigs
// in the same RtcEventVideoSendStreamConfig. Look into whether we should drop
// backwards compatibility in the parser.
ASSERT_EQ(logged_event.configs.size(), 1u);
- VerifyLoggedStreamConfig(*original_event.config_, logged_event.configs[0]);
+ VerifyLoggedStreamConfig(original_event.config(), logged_event.configs[0]);
}
} // namespace test
diff --git a/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc b/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc
index 5948ac3..be9550a 100644
--- a/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc
+++ b/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc
@@ -51,7 +51,7 @@
return false;
}
auto ana_event = static_cast<RtcEventAudioNetworkAdaptation*>(arg);
- return *ana_event->config_ == config;
+ return ana_event->config() == config;
}
MATCHER_P(EncoderRuntimeConfigIs, config, "") {
diff --git a/modules/audio_coding/audio_network_adaptor/event_log_writer_unittest.cc b/modules/audio_coding/audio_network_adaptor/event_log_writer_unittest.cc
index df97594..42189c3 100644
--- a/modules/audio_coding/audio_network_adaptor/event_log_writer_unittest.cc
+++ b/modules/audio_coding/audio_network_adaptor/event_log_writer_unittest.cc
@@ -36,7 +36,7 @@
return false;
}
auto ana_event = static_cast<RtcEventAudioNetworkAdaptation*>(arg);
- return *ana_event->config_ == config;
+ return ana_event->config() == config;
}
struct EventLogWriterStates {
diff --git a/modules/bitrate_controller/send_side_bandwidth_estimation_unittest.cc b/modules/bitrate_controller/send_side_bandwidth_estimation_unittest.cc
index becc616..ccfbd85 100644
--- a/modules/bitrate_controller/send_side_bandwidth_estimation_unittest.cc
+++ b/modules/bitrate_controller/send_side_bandwidth_estimation_unittest.cc
@@ -23,7 +23,7 @@
return false;
}
auto bwe_event = static_cast<RtcEventBweUpdateLossBased*>(arg);
- return bwe_event->bitrate_bps_ > 0 && bwe_event->fraction_loss_ == 0;
+ return bwe_event->bitrate_bps() > 0 && bwe_event->fraction_loss() == 0;
}
MATCHER(LossBasedBweUpdateWithBitrateAndLossFraction, "") {
@@ -31,7 +31,7 @@
return false;
}
auto bwe_event = static_cast<RtcEventBweUpdateLossBased*>(arg);
- return bwe_event->bitrate_bps_ > 0 && bwe_event->fraction_loss_ > 0;
+ return bwe_event->bitrate_bps() > 0 && bwe_event->fraction_loss() > 0;
}
void TestProbing(bool use_delay_based) {
