admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Hide RtcEvent members behind accessors

Browse Source 
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}
This commit is contained in:
Elad Alon 2018-11-09 21:50:14 +01:00
parent eb809f30d1
commit 0b1b5c1b2a
32 changed files with 410 additions and 330 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
logging/BUILD.gn
View File

@ -88,6 +88,7 @@ rtc_source_set("rtc_event_audio") {
":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_source_set("rtc_event_rtp_rtcp") {
":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 @@ rtc_source_set("rtc_event_video") {
deps = [
":rtc_event_log_api",
":rtc_stream_config",
"../rtc_base:checks",
"../rtc_base:ptr_util",
"//third_party/abseil-cpp/absl/memory",
]

139
logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.cc
View File

@ -356,37 +356,37 @@ std::string RtcEventLogEncoderLegacy::Encode(const RtcEvent& event) {
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::EncodeAudioNetworkAdaptation(
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::EncodeAudioPlayout(
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::EncodeAudioReceiveStreamConfig(
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::EncodeAudioSendStreamConfig(
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::EncodeBweUpdateDelayBased(
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::EncodeBweUpdateLossBased(
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::EncodeIceCandidatePairConfig(
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::EncodeProbeClusterCreated(
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::EncodeProbeResultFailure(
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::EncodeVideoReceiveStreamConfig(
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 @@ std::string RtcEventLogEncoderLegacy::EncodeVideoSendStreamConfig(
// 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;

305
logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc
View File

@ -296,11 +296,11 @@ void EncodeRtcpPacket(rtc::ArrayView<const EventType*> batch,
// 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 @@ void EncodeRtcpPacket(rtc::ArrayView<const EventType*> batch,
// 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 @@ void EncodeRtcpPacket(rtc::ArrayView<const EventType*> batch,
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 @@ void EncodeRtpPacket(const std::vector<const EventType*>& batch,
// 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 @@ void EncodeRtpPacket(const std::vector<const EventType*>& batch,
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 @@ void EncodeRtpPacket(const std::vector<const EventType*>& batch,
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 @@ void EncodeRtpPacket(const std::vector<const EventType*>& batch,
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 @@ void EncodeRtpPacket(const std::vector<const EventType*>& batch,
{
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 @@ void EncodeRtpPacket(const std::vector<const EventType*>& batch,
// 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 @@ void EncodeRtpPacket(const std::vector<const EventType*>& batch,
// 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 @@ void EncodeRtpPacket(const std::vector<const EventType*>& batch,
// 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 @@ void EncodeRtpPacket(const std::vector<const EventType*>& batch,
// 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 @@ void EncodeRtpPacket(const std::vector<const EventType*>& batch,
// 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 @@ void EncodeRtpPacket(const std::vector<const EventType*>& batch,
// 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 @@ void EncodeRtpPacket(const std::vector<const EventType*>& batch,
// 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 @@ void EncodeRtpPacket(const std::vector<const EventType*>& batch,
// 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 @@ void EncodeRtpPacket(const std::vector<const EventType*>& batch,
// 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 @@ void EncodeRtpPacket(const std::vector<const EventType*>& batch,
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 @@ void EncodeRtpPacket(const std::vector<const EventType*>& batch,
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 @@ void EncodeRtpPacket(const std::vector<const EventType*>& batch,
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 @@ void EncodeRtpPacket(const std::vector<const EventType*>& batch,
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 @@ void EncodeRtpPacket(const std::vector<const EventType*>& batch,
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 @@ void EncodeRtpPacket(const std::vector<const EventType*>& batch,
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 @@ std::string RtcEventLogEncoderNewFormat::EncodeBatch(
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 @@ void RtcEventLogEncoderNewFormat::EncodeAlrState(
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 @@ void RtcEventLogEncoderNewFormat::EncodeAudioNetworkAdaptation(
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 @@ void RtcEventLogEncoderNewFormat::EncodeAudioNetworkAdaptation(
// 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 @@ void RtcEventLogEncoderNewFormat::EncodeAudioNetworkAdaptation(
// 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 @@ void RtcEventLogEncoderNewFormat::EncodeAudioNetworkAdaptation(
// 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 @@ void RtcEventLogEncoderNewFormat::EncodeAudioNetworkAdaptation(
// 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 @@ void RtcEventLogEncoderNewFormat::EncodeAudioNetworkAdaptation(
// 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 @@ void RtcEventLogEncoderNewFormat::EncodeAudioNetworkAdaptation(
// 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 @@ void RtcEventLogEncoderNewFormat::EncodeAudioNetworkAdaptation(
// 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 @@ void RtcEventLogEncoderNewFormat::EncodeAudioPlayout(
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 @@ void RtcEventLogEncoderNewFormat::EncodeAudioPlayout(
// 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 @@ void RtcEventLogEncoderNewFormat::EncodeAudioPlayout(
// 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 @@ void RtcEventLogEncoderNewFormat::EncodeAudioRecvStreamConfig(
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 @@ void RtcEventLogEncoderNewFormat::EncodeAudioSendStreamConfig(
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 @@ void RtcEventLogEncoderNewFormat::EncodeBweUpdateDelayBased(
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 @@ void RtcEventLogEncoderNewFormat::EncodeBweUpdateDelayBased(
// 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 @@ void RtcEventLogEncoderNewFormat::EncodeBweUpdateDelayBased(
// 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 @@ void RtcEventLogEncoderNewFormat::EncodeBweUpdateDelayBased(
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 @@ void RtcEventLogEncoderNewFormat::EncodeBweUpdateLossBased(
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 @@ void RtcEventLogEncoderNewFormat::EncodeBweUpdateLossBased(
// 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 @@ void RtcEventLogEncoderNewFormat::EncodeBweUpdateLossBased(
// 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 @@ void RtcEventLogEncoderNewFormat::EncodeBweUpdateLossBased(
// 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 @@ void RtcEventLogEncoderNewFormat::EncodeBweUpdateLossBased(
// 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 @@ void RtcEventLogEncoderNewFormat::EncodeProbeClusterCreated(
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 @@ void RtcEventLogEncoderNewFormat::EncodeProbeResultFailure(
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 @@ void RtcEventLogEncoderNewFormat::EncodeProbeResultSuccess(
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 @@ void RtcEventLogEncoderNewFormat::EncodeVideoRecvStreamConfig(
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 @@ void RtcEventLogEncoderNewFormat::EncodeVideoSendStreamConfig(
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 @@ void RtcEventLogEncoderNewFormat::EncodeIceCandidatePairConfig(
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 @@ void RtcEventLogEncoderNewFormat::EncodeIceCandidatePairEvent(
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?
}

6
logging/rtc_event_log/events/rtc_event.h
View File

@ -57,10 +57,14 @@ class RtcEvent {
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

4
logging/rtc_event_log/events/rtc_event_alr_state.h
View File

@ -28,10 +28,12 @@ class RtcEventAlrState final : public RtcEvent {
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

5
logging/rtc_event_log/events/rtc_event_audio_network_adaptation.cc
View File

@ -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)

4
logging/rtc_event_log/events/rtc_event_audio_network_adaptation.h
View File

@ -31,10 +31,12 @@ class RtcEventAudioNetworkAdaptation final : public RtcEvent {
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

4
logging/rtc_event_log/events/rtc_event_audio_playout.h
View File

@ -29,10 +29,12 @@ class RtcEventAudioPlayout final : public RtcEvent {
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

5
logging/rtc_event_log/events/rtc_event_audio_receive_stream_config.cc
View File

@ -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)

4
logging/rtc_event_log/events/rtc_event_audio_receive_stream_config.h
View File

@ -33,11 +33,13 @@ class RtcEventAudioReceiveStreamConfig final : public RtcEvent {
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

5
logging/rtc_event_log/events/rtc_event_audio_send_stream_config.cc
View File

@ -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)

4
logging/rtc_event_log/events/rtc_event_audio_send_stream_config.h
View File

@ -33,10 +33,12 @@ class RtcEventAudioSendStreamConfig final : public RtcEvent {
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

7
logging/rtc_event_log/events/rtc_event_bwe_update_delay_based.h
View File

@ -32,11 +32,14 @@ class RtcEventBweUpdateDelayBased final : public RtcEvent {
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

10
logging/rtc_event_log/events/rtc_event_bwe_update_loss_based.h
View File

@ -31,12 +31,16 @@ class RtcEventBweUpdateLossBased final : public RtcEvent {
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

7
logging/rtc_event_log/events/rtc_event_ice_candidate_pair.h
View File

@ -38,11 +38,14 @@ class RtcEventIceCandidatePair final : public RtcEvent {
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

12
logging/rtc_event_log/events/rtc_event_ice_candidate_pair_config.h
View File

@ -94,12 +94,18 @@ class RtcEventIceCandidatePairConfig final : public RtcEvent {
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

11
logging/rtc_event_log/events/rtc_event_probe_cluster_created.h
View File

@ -32,13 +32,18 @@ class RtcEventProbeClusterCreated final : public RtcEvent {
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

7
logging/rtc_event_log/events/rtc_event_probe_result_failure.h
View File

@ -36,11 +36,14 @@ class RtcEventProbeResultFailure final : public RtcEvent {
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

7
logging/rtc_event_log/events/rtc_event_probe_result_success.h
View File

@ -29,11 +29,14 @@ class RtcEventProbeResultSuccess final : public RtcEvent {
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

4
logging/rtc_event_log/events/rtc_event_rtcp_packet_incoming.h
View File

@ -31,10 +31,12 @@ class RtcEventRtcpPacketIncoming final : public RtcEvent {
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

4
logging/rtc_event_log/events/rtc_event_rtcp_packet_outgoing.h
View File

@ -31,10 +31,12 @@ class RtcEventRtcpPacketOutgoing final : public RtcEvent {
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

1
logging/rtc_event_log/events/rtc_event_rtp_packet_incoming.cc
View File

@ -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 {

11
logging/rtc_event_log/events/rtc_event_rtp_packet_incoming.h
View File

@ -35,13 +35,18 @@ class RtcEventRtpPacketIncoming final : public RtcEvent {
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

1
logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.cc
View File

@ -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 {

13
logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h
View File

@ -36,14 +36,21 @@ class RtcEventRtpPacketOutgoing final : public RtcEvent {
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

5
logging/rtc_event_log/events/rtc_event_video_receive_stream_config.cc
View File

@ -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)

4
logging/rtc_event_log/events/rtc_event_video_receive_stream_config.h
View File

@ -30,11 +30,13 @@ class RtcEventVideoReceiveStreamConfig final : public RtcEvent {
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

4
logging/rtc_event_log/events/rtc_event_video_send_stream_config.h
View File

@ -30,10 +30,12 @@ class RtcEventVideoSendStreamConfig final : public RtcEvent {
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

136
logging/rtc_event_log/rtc_event_log_unittest_helper.cc
View File

@ -503,37 +503,37 @@ EventGenerator::NewVideoSendStreamConfig(
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 VerifyLoggedAudioNetworkAdaptationEvent(
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 VerifyLoggedRtpHeader(const RtpPacket& original_header,
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 VerifyLoggedStreamConfig(const rtclog::StreamConfig& original_config,
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

2
modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc
View File

@ -51,7 +51,7 @@ MATCHER_P(IsRtcEventAnaConfigEqualTo, config, "") {
return false;
}
auto ana_event = static_cast<RtcEventAudioNetworkAdaptation*>(arg);
return *ana_event->config_ == config;
return ana_event->config() == config;
}
MATCHER_P(EncoderRuntimeConfigIs, config, "") {

2
modules/audio_coding/audio_network_adaptor/event_log_writer_unittest.cc
View File

@ -36,7 +36,7 @@ MATCHER_P(IsRtcEventAnaConfigEqualTo, config, "") {
return false;
}
auto ana_event = static_cast<RtcEventAudioNetworkAdaptation*>(arg);
return *ana_event->config_ == config;
return ana_event->config() == config;
}
struct EventLogWriterStates {

4
modules/bitrate_controller/send_side_bandwidth_estimation_unittest.cc
View File

@ -23,7 +23,7 @@ MATCHER(LossBasedBweUpdateWithBitrateOnly, "") {
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 @@ MATCHER(LossBasedBweUpdateWithBitrateAndLossFraction, "") {
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) {