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

Change rtc event log packet messages implementation to save full rtp packet

Browse Source 
Keeping just the header doesn't save memory because header is taken as slice
of the original packet (and thus keeps a reference to the buffer containing
full packet)
Keeping full packet is simpler and avoid extra unused buffer created during
RtpPacket default contruction

Bug: b/187593466
Change-Id: I78d7201d110092fc039203e1caa2fb9c3afbc079
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/218161
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#33974}
This commit is contained in:
Danil Chapovalov 2021-05-10 17:19:50 +02:00 committed by WebRTC LUCI CQ
parent 64a79c71c4
commit 6e661f47cf
8 changed files with 114 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -15,6 +15,7 @@
#include <vector>
#include "absl/types/optional.h"
#include "api/array_view.h"
#include "api/network_state_predictor.h"
#include "api/rtp_headers.h"
#include "api/rtp_parameters.h"
@ -593,14 +594,14 @@ std::string RtcEventLogEncoderLegacy::EncodeRtcpPacketOutgoing(
std::string RtcEventLogEncoderLegacy::EncodeRtpPacketIncoming(
const RtcEventRtpPacketIncoming& event) {
return EncodeRtpPacket(event.timestamp_us(), event.header(),
return EncodeRtpPacket(event.timestamp_us(), event.RawHeader(),
event.packet_length(), PacedPacketInfo::kNotAProbe,
true);
}
std::string RtcEventLogEncoderLegacy::EncodeRtpPacketOutgoing(
const RtcEventRtpPacketOutgoing& event) {
return EncodeRtpPacket(event.timestamp_us(), event.header(),
return EncodeRtpPacket(event.timestamp_us(), event.RawHeader(),
event.packet_length(), event.probe_cluster_id(),
false);
}
@ -736,7 +737,7 @@ std::string RtcEventLogEncoderLegacy::EncodeRtcpPacket(
std::string RtcEventLogEncoderLegacy::EncodeRtpPacket(
int64_t timestamp_us,
const webrtc::RtpPacket& header,
rtc::ArrayView<const uint8_t> header,
size_t packet_length,
int probe_cluster_id,
bool is_incoming) {

3
logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.h
View File

@ -15,6 +15,7 @@
#include <memory>
#include <string>
#include "api/array_view.h"
#include "logging/rtc_event_log/encoder/rtc_event_log_encoder.h"
#include "rtc_base/buffer.h"
@ -94,7 +95,7 @@ class RtcEventLogEncoderLegacy final : public RtcEventLogEncoder {
const rtc::Buffer& packet,
bool is_incoming);
std::string EncodeRtpPacket(int64_t timestamp_us,
const RtpPacket& header,
rtc::ArrayView<const uint8_t> header,
size_t packet_length,
int probe_cluster_id,
bool is_incoming);

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

@ -394,12 +394,12 @@ 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_ms());
proto_batch->set_marker(base_event->header().Marker());
proto_batch->set_marker(base_event->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_type(base_event->PayloadType());
proto_batch->set_sequence_number(base_event->SequenceNumber());
proto_batch->set_rtp_timestamp(base_event->Timestamp());
proto_batch->set_ssrc(base_event->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());
@ -408,8 +408,7 @@ void EncodeRtpPacket(const std::vector<const EventType*>& batch,
absl::optional<uint64_t> base_transport_sequence_number;
{
uint16_t seqnum;
if (base_event->header().template GetExtension<TransportSequenceNumber>(
&seqnum)) {
if (base_event->template GetExtension<TransportSequenceNumber>(&seqnum)) {
proto_batch->set_transport_sequence_number(seqnum);
base_transport_sequence_number = seqnum;
}
@ -418,8 +417,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>(
&offset)) {
if (base_event->template GetExtension<TransmissionOffset>(&offset)) {
proto_batch->set_transmission_time_offset(offset);
unsigned_base_transmission_time_offset = ToUnsigned(offset);
}
@ -428,8 +426,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>(
&sendtime)) {
if (base_event->template GetExtension<AbsoluteSendTime>(&sendtime)) {
proto_batch->set_absolute_send_time(sendtime);
base_absolute_send_time = sendtime;
}
@ -438,8 +435,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>(
&video_rotation)) {
if (base_event->template GetExtension<VideoOrientation>(&video_rotation)) {
proto_batch->set_video_rotation(
ConvertVideoRotationToCVOByte(video_rotation));
base_video_rotation = ConvertVideoRotationToCVOByte(video_rotation);
@ -451,8 +447,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->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);
@ -484,9 +480,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->Marker();
}
encoded_deltas = EncodeDeltas(base_event->header().Marker(), values);
encoded_deltas = EncodeDeltas(base_event->Marker(), values);
if (!encoded_deltas.empty()) {
proto_batch->set_marker_deltas(encoded_deltas);
}
@ -494,9 +490,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->PayloadType();
}
encoded_deltas = EncodeDeltas(base_event->header().PayloadType(), values);
encoded_deltas = EncodeDeltas(base_event->PayloadType(), values);
if (!encoded_deltas.empty()) {
proto_batch->set_payload_type_deltas(encoded_deltas);
}
@ -504,9 +500,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->SequenceNumber();
}
encoded_deltas = EncodeDeltas(base_event->header().SequenceNumber(), values);
encoded_deltas = EncodeDeltas(base_event->SequenceNumber(), values);
if (!encoded_deltas.empty()) {
proto_batch->set_sequence_number_deltas(encoded_deltas);
}
@ -514,9 +510,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->Timestamp();
}
encoded_deltas = EncodeDeltas(base_event->header().Timestamp(), values);
encoded_deltas = EncodeDeltas(base_event->Timestamp(), values);
if (!encoded_deltas.empty()) {
proto_batch->set_rtp_timestamp_deltas(encoded_deltas);
}
@ -524,9 +520,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->Ssrc();
}
encoded_deltas = EncodeDeltas(base_event->header().Ssrc(), values);
encoded_deltas = EncodeDeltas(base_event->Ssrc(), values);
if (!encoded_deltas.empty()) {
proto_batch->set_ssrc_deltas(encoded_deltas);
}
@ -565,8 +561,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>(
&seqnum)) {
if (event->template GetExtension<TransportSequenceNumber>(&seqnum)) {
values[i] = seqnum;
} else {
values[i].reset();
@ -581,7 +576,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->template GetExtension<TransmissionOffset>(&offset)) {
values[i] = ToUnsigned(offset);
} else {
values[i].reset();
@ -596,7 +591,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->template GetExtension<AbsoluteSendTime>(&sendtime)) {
values[i] = sendtime;
} else {
values[i].reset();
@ -611,8 +606,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>(
&video_rotation)) {
if (event->template GetExtension<VideoOrientation>(&video_rotation)) {
values[i] = ConvertVideoRotationToCVOByte(video_rotation);
} else {
values[i].reset();
@ -628,8 +622,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->template GetExtension<AudioLevel>(&voice_activity,
&audio_level)) {
RTC_DCHECK_LE(audio_level, 0x7Fu);
values[i] = audio_level;
} else {
@ -646,8 +640,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->template GetExtension<AudioLevel>(&voice_activity,
&audio_level)) {
RTC_DCHECK_LE(audio_level, 0x7Fu);
values[i] = voice_activity;
} else {
@ -823,14 +817,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->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->Ssrc()];
v.emplace_back(rtc_event);
break;
}

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

@ -18,22 +18,11 @@ namespace webrtc {
RtcEventRtpPacketIncoming::RtcEventRtpPacketIncoming(
const RtpPacketReceived& packet)
: payload_length_(packet.payload_size()),
header_length_(packet.headers_size()),
padding_length_(packet.padding_size()) {
header_.CopyHeaderFrom(packet);
RTC_DCHECK_EQ(packet.size(),
payload_length_ + header_length_ + padding_length_);
}
: packet_(packet) {}
RtcEventRtpPacketIncoming::RtcEventRtpPacketIncoming(
const RtcEventRtpPacketIncoming& other)
: RtcEvent(other.timestamp_us_),
payload_length_(other.payload_length_),
header_length_(other.header_length_),
padding_length_(other.padding_length_) {
header_.CopyHeaderFrom(other.header_);
}
: RtcEvent(other.timestamp_us_), packet_(other.packet_) {}
RtcEventRtpPacketIncoming::~RtcEventRtpPacketIncoming() = default;

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

@ -11,8 +11,12 @@
#ifndef LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_RTP_PACKET_INCOMING_H_
#define LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_RTP_PACKET_INCOMING_H_
#include <cstddef>
#include <cstdint>
#include <memory>
#include <utility>
#include "api/array_view.h"
#include "api/rtc_event_log/rtc_event.h"
#include "modules/rtp_rtcp/source/rtp_packet.h"
@ -32,22 +36,33 @@ class RtcEventRtpPacketIncoming final : public RtcEvent {
std::unique_ptr<RtcEventRtpPacketIncoming> Copy() const;
size_t packet_length() const {
return payload_length_ + header_length_ + padding_length_;
size_t packet_length() const { return packet_.size(); }
rtc::ArrayView<const uint8_t> RawHeader() const {
return rtc::MakeArrayView(packet_.data(), header_length());
}
uint32_t Ssrc() const { return packet_.Ssrc(); }
uint32_t Timestamp() const { return packet_.Timestamp(); }
uint16_t SequenceNumber() const { return packet_.SequenceNumber(); }
uint8_t PayloadType() const { return packet_.PayloadType(); }
bool Marker() const { return packet_.Marker(); }
template <typename ExtensionTrait, typename... Args>
bool GetExtension(Args&&... args) const {
return packet_.GetExtension<ExtensionTrait>(std::forward<Args>(args)...);
}
template <typename ExtensionTrait>
bool HasExtension() const {
return packet_.HasExtension<ExtensionTrait>();
}
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_; }
size_t payload_length() const { return packet_.payload_size(); }
size_t header_length() const { return packet_.headers_size(); }
size_t padding_length() const { return packet_.padding_size(); }
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.
const RtpPacket packet_;
};
} // namespace webrtc

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

@ -19,24 +19,13 @@ namespace webrtc {
RtcEventRtpPacketOutgoing::RtcEventRtpPacketOutgoing(
const RtpPacketToSend& packet,
int probe_cluster_id)
: payload_length_(packet.payload_size()),
header_length_(packet.headers_size()),
padding_length_(packet.padding_size()),
probe_cluster_id_(probe_cluster_id) {
header_.CopyHeaderFrom(packet);
RTC_DCHECK_EQ(packet.size(),
payload_length_ + header_length_ + padding_length_);
}
: packet_(packet), probe_cluster_id_(probe_cluster_id) {}
RtcEventRtpPacketOutgoing::RtcEventRtpPacketOutgoing(
const RtcEventRtpPacketOutgoing& other)
: RtcEvent(other.timestamp_us_),
payload_length_(other.payload_length_),
header_length_(other.header_length_),
padding_length_(other.padding_length_),
probe_cluster_id_(other.probe_cluster_id_) {
header_.CopyHeaderFrom(other.header_);
}
packet_(other.packet_),
probe_cluster_id_(other.probe_cluster_id_) {}
RtcEventRtpPacketOutgoing::~RtcEventRtpPacketOutgoing() = default;

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

@ -11,8 +11,12 @@
#ifndef LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_RTP_PACKET_OUTGOING_H_
#define LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_RTP_PACKET_OUTGOING_H_
#include <cstddef>
#include <cstdint>
#include <memory>
#include <utility>
#include "api/array_view.h"
#include "api/rtc_event_log/rtc_event.h"
#include "modules/rtp_rtcp/source/rtp_packet.h"
@ -33,23 +37,34 @@ class RtcEventRtpPacketOutgoing final : public RtcEvent {
std::unique_ptr<RtcEventRtpPacketOutgoing> Copy() const;
size_t packet_length() const {
return payload_length_ + header_length_ + padding_length_;
size_t packet_length() const { return packet_.size(); }
rtc::ArrayView<const uint8_t> RawHeader() const {
return rtc::MakeArrayView(packet_.data(), header_length());
}
uint32_t Ssrc() const { return packet_.Ssrc(); }
uint32_t Timestamp() const { return packet_.Timestamp(); }
uint16_t SequenceNumber() const { return packet_.SequenceNumber(); }
uint8_t PayloadType() const { return packet_.PayloadType(); }
bool Marker() const { return packet_.Marker(); }
template <typename ExtensionTrait, typename... Args>
bool GetExtension(Args&&... args) const {
return packet_.GetExtension<ExtensionTrait>(std::forward<Args>(args)...);
}
template <typename ExtensionTrait>
bool HasExtension() const {
return packet_.HasExtension<ExtensionTrait>();
}
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_; }
size_t payload_length() const { return packet_.payload_size(); }
size_t header_length() const { return packet_.headers_size(); }
size_t padding_length() const { return packet_.padding_size(); }
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.
const RtpPacket packet_;
// TODO(eladalon): Delete |probe_cluster_id_| along with legacy encoding.
const int probe_cluster_id_;
};

41
logging/rtc_event_log/rtc_event_log_unittest_helper.cc
View File

@ -931,7 +931,8 @@ void EventVerifier::VerifyLoggedIceCandidatePairEvent(
}
}
void VerifyLoggedRtpHeader(const RtpPacket& original_header,
template <typename Event>
void VerifyLoggedRtpHeader(const Event& original_header,
const RTPHeader& logged_header) {
// Standard RTP header.
EXPECT_EQ(original_header.Marker(), logged_header.markerBit);
@ -940,53 +941,57 @@ void VerifyLoggedRtpHeader(const RtpPacket& original_header,
EXPECT_EQ(original_header.Timestamp(), logged_header.timestamp);
EXPECT_EQ(original_header.Ssrc(), logged_header.ssrc);
EXPECT_EQ(original_header.headers_size(), logged_header.headerLength);
EXPECT_EQ(original_header.header_length(), logged_header.headerLength);
// TransmissionOffset header extension.
ASSERT_EQ(original_header.HasExtension<TransmissionOffset>(),
ASSERT_EQ(original_header.template HasExtension<TransmissionOffset>(),
logged_header.extension.hasTransmissionTimeOffset);
if (logged_header.extension.hasTransmissionTimeOffset) {
int32_t offset;
ASSERT_TRUE(original_header.GetExtension<TransmissionOffset>(&offset));
ASSERT_TRUE(
original_header.template GetExtension<TransmissionOffset>(&offset));
EXPECT_EQ(offset, logged_header.extension.transmissionTimeOffset);
}
// AbsoluteSendTime header extension.
ASSERT_EQ(original_header.HasExtension<AbsoluteSendTime>(),
ASSERT_EQ(original_header.template HasExtension<AbsoluteSendTime>(),
logged_header.extension.hasAbsoluteSendTime);
if (logged_header.extension.hasAbsoluteSendTime) {
uint32_t sendtime;
ASSERT_TRUE(original_header.GetExtension<AbsoluteSendTime>(&sendtime));
ASSERT_TRUE(
original_header.template GetExtension<AbsoluteSendTime>(&sendtime));
EXPECT_EQ(sendtime, logged_header.extension.absoluteSendTime);
}
// TransportSequenceNumber header extension.
ASSERT_EQ(original_header.HasExtension<TransportSequenceNumber>(),
ASSERT_EQ(original_header.template HasExtension<TransportSequenceNumber>(),
logged_header.extension.hasTransportSequenceNumber);
if (logged_header.extension.hasTransportSequenceNumber) {
uint16_t seqnum;
ASSERT_TRUE(original_header.GetExtension<TransportSequenceNumber>(&seqnum));
ASSERT_TRUE(original_header.template GetExtension<TransportSequenceNumber>(
&seqnum));
EXPECT_EQ(seqnum, logged_header.extension.transportSequenceNumber);
}
// AudioLevel header extension.
ASSERT_EQ(original_header.HasExtension<AudioLevel>(),
ASSERT_EQ(original_header.template HasExtension<AudioLevel>(),
logged_header.extension.hasAudioLevel);
if (logged_header.extension.hasAudioLevel) {
bool voice_activity;
uint8_t audio_level;
ASSERT_TRUE(original_header.GetExtension<AudioLevel>(&voice_activity,
&audio_level));
ASSERT_TRUE(original_header.template GetExtension<AudioLevel>(
&voice_activity, &audio_level));
EXPECT_EQ(voice_activity, logged_header.extension.voiceActivity);
EXPECT_EQ(audio_level, logged_header.extension.audioLevel);
}
// VideoOrientation header extension.
ASSERT_EQ(original_header.HasExtension<VideoOrientation>(),
ASSERT_EQ(original_header.template HasExtension<VideoOrientation>(),
logged_header.extension.hasVideoRotation);
if (logged_header.extension.hasVideoRotation) {
uint8_t rotation;
ASSERT_TRUE(original_header.GetExtension<VideoOrientation>(&rotation));
ASSERT_TRUE(
original_header.template GetExtension<VideoOrientation>(&rotation));
EXPECT_EQ(ConvertCVOByteToVideoRotation(rotation),
logged_header.extension.videoRotation);
}
@ -1015,8 +1020,7 @@ void EventVerifier::VerifyLoggedRtpPacketIncoming(
const LoggedRtpPacketIncoming& logged_event) const {
EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
EXPECT_EQ(original_event.header().headers_size(),
logged_event.rtp.header_length);
EXPECT_EQ(original_event.header_length(), logged_event.rtp.header_length);
EXPECT_EQ(original_event.packet_length(), logged_event.rtp.total_length);
@ -1025,7 +1029,7 @@ void EventVerifier::VerifyLoggedRtpPacketIncoming(
EXPECT_EQ(original_event.padding_length(),
logged_event.rtp.header.paddingLength);
VerifyLoggedRtpHeader(original_event.header(), logged_event.rtp.header);
VerifyLoggedRtpHeader(original_event, logged_event.rtp.header);
}
void EventVerifier::VerifyLoggedRtpPacketOutgoing(
@ -1033,8 +1037,7 @@ void EventVerifier::VerifyLoggedRtpPacketOutgoing(
const LoggedRtpPacketOutgoing& logged_event) const {
EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
EXPECT_EQ(original_event.header().headers_size(),
logged_event.rtp.header_length);
EXPECT_EQ(original_event.header_length(), logged_event.rtp.header_length);
EXPECT_EQ(original_event.packet_length(), logged_event.rtp.total_length);
@ -1046,7 +1049,7 @@ void EventVerifier::VerifyLoggedRtpPacketOutgoing(
// 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, logged_event.rtp.header);
}
void EventVerifier::VerifyLoggedGenericPacketSent(