1 /*
2 * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "logging/rtc_event_log/rtc_event_log_unittest_helper.h"
12
13 #include <string.h> // memcmp
14
15 #include <cmath>
16 #include <cstdint>
17 #include <limits>
18 #include <memory>
19 #include <numeric>
20 #include <string>
21 #include <utility>
22 #include <vector>
23
24 #include "absl/types/optional.h"
25 #include "api/array_view.h"
26 #include "api/rtp_headers.h"
27 #include "api/rtp_parameters.h"
28 #include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h"
29 #include "modules/remote_bitrate_estimator/include/bwe_defines.h"
30 #include "modules/rtp_rtcp/include/rtp_cvo.h"
31 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
32 #include "modules/rtp_rtcp/source/rtcp_packet/dlrr.h"
33 #include "modules/rtp_rtcp/source/rtcp_packet/rrtr.h"
34 #include "modules/rtp_rtcp/source/rtcp_packet/target_bitrate.h"
35 #include "modules/rtp_rtcp/source/rtp_header_extensions.h"
36 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
37 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
38 #include "rtc_base/buffer.h"
39 #include "rtc_base/checks.h"
40 #include "rtc_base/time_utils.h"
41 #include "system_wrappers/include/ntp_time.h"
42 #include "test/gtest.h"
43
44 namespace webrtc {
45
46 namespace test {
47
48 namespace {
49
50 struct ExtensionPair {
51 RTPExtensionType type;
52 const char* name;
53 };
54
55 constexpr int kMaxCsrcs = 3;
56
57 // Maximum serialized size of a header extension, including 1 byte ID.
58 constexpr int kMaxExtensionSizeBytes = 4;
59 constexpr int kMaxNumExtensions = 5;
60
61 constexpr ExtensionPair kExtensions[kMaxNumExtensions] = {
62 {RTPExtensionType::kRtpExtensionTransmissionTimeOffset,
63 RtpExtension::kTimestampOffsetUri},
64 {RTPExtensionType::kRtpExtensionAbsoluteSendTime,
65 RtpExtension::kAbsSendTimeUri},
66 {RTPExtensionType::kRtpExtensionTransportSequenceNumber,
67 RtpExtension::kTransportSequenceNumberUri},
68 {RTPExtensionType::kRtpExtensionAudioLevel, RtpExtension::kAudioLevelUri},
69 {RTPExtensionType::kRtpExtensionVideoRotation,
70 RtpExtension::kVideoRotationUri}};
71
72 template <typename T>
ShuffleInPlace(Random * prng,rtc::ArrayView<T> array)73 void ShuffleInPlace(Random* prng, rtc::ArrayView<T> array) {
74 RTC_DCHECK_LE(array.size(), std::numeric_limits<uint32_t>::max());
75 for (uint32_t i = 0; i + 1 < array.size(); i++) {
76 uint32_t other = prng->Rand(i, static_cast<uint32_t>(array.size() - 1));
77 std::swap(array[i], array[other]);
78 }
79 }
80
GetExtensionId(const std::vector<RtpExtension> & extensions,const std::string & uri)81 absl::optional<int> GetExtensionId(const std::vector<RtpExtension>& extensions,
82 const std::string& uri) {
83 for (const auto& extension : extensions) {
84 if (extension.uri == uri)
85 return extension.id;
86 }
87 return absl::nullopt;
88 }
89
90 } // namespace
91
NewAlrState()92 std::unique_ptr<RtcEventAlrState> EventGenerator::NewAlrState() {
93 return std::make_unique<RtcEventAlrState>(prng_.Rand<bool>());
94 }
95
NewAudioPlayout(uint32_t ssrc)96 std::unique_ptr<RtcEventAudioPlayout> EventGenerator::NewAudioPlayout(
97 uint32_t ssrc) {
98 return std::make_unique<RtcEventAudioPlayout>(ssrc);
99 }
100
101 std::unique_ptr<RtcEventAudioNetworkAdaptation>
NewAudioNetworkAdaptation()102 EventGenerator::NewAudioNetworkAdaptation() {
103 std::unique_ptr<AudioEncoderRuntimeConfig> config =
104 std::make_unique<AudioEncoderRuntimeConfig>();
105
106 config->bitrate_bps = prng_.Rand(0, 3000000);
107 config->enable_fec = prng_.Rand<bool>();
108 config->enable_dtx = prng_.Rand<bool>();
109 config->frame_length_ms = prng_.Rand(10, 120);
110 config->num_channels = prng_.Rand(1, 2);
111 config->uplink_packet_loss_fraction = prng_.Rand<float>();
112
113 return std::make_unique<RtcEventAudioNetworkAdaptation>(std::move(config));
114 }
115
116 std::unique_ptr<RtcEventBweUpdateDelayBased>
NewBweUpdateDelayBased()117 EventGenerator::NewBweUpdateDelayBased() {
118 constexpr int32_t kMaxBweBps = 20000000;
119 int32_t bitrate_bps = prng_.Rand(0, kMaxBweBps);
120 BandwidthUsage state = static_cast<BandwidthUsage>(
121 prng_.Rand(static_cast<uint32_t>(BandwidthUsage::kLast) - 1));
122 return std::make_unique<RtcEventBweUpdateDelayBased>(bitrate_bps, state);
123 }
124
125 std::unique_ptr<RtcEventBweUpdateLossBased>
NewBweUpdateLossBased()126 EventGenerator::NewBweUpdateLossBased() {
127 constexpr int32_t kMaxBweBps = 20000000;
128 constexpr int32_t kMaxPackets = 1000;
129 int32_t bitrate_bps = prng_.Rand(0, kMaxBweBps);
130 uint8_t fraction_lost = prng_.Rand<uint8_t>();
131 int32_t total_packets = prng_.Rand(1, kMaxPackets);
132
133 return std::make_unique<RtcEventBweUpdateLossBased>(
134 bitrate_bps, fraction_lost, total_packets);
135 }
136
137 std::unique_ptr<RtcEventDtlsTransportState>
NewDtlsTransportState()138 EventGenerator::NewDtlsTransportState() {
139 DtlsTransportState state = static_cast<DtlsTransportState>(
140 prng_.Rand(static_cast<uint32_t>(DtlsTransportState::kNumValues) - 1));
141
142 return std::make_unique<RtcEventDtlsTransportState>(state);
143 }
144
145 std::unique_ptr<RtcEventDtlsWritableState>
NewDtlsWritableState()146 EventGenerator::NewDtlsWritableState() {
147 bool writable = prng_.Rand<bool>();
148 return std::make_unique<RtcEventDtlsWritableState>(writable);
149 }
150
NewFrameDecodedEvent(uint32_t ssrc)151 std::unique_ptr<RtcEventFrameDecoded> EventGenerator::NewFrameDecodedEvent(
152 uint32_t ssrc) {
153 constexpr int kMinRenderDelayMs = 1;
154 constexpr int kMaxRenderDelayMs = 2000000;
155 constexpr int kMaxWidth = 15360;
156 constexpr int kMaxHeight = 8640;
157 constexpr int kMinWidth = 16;
158 constexpr int kMinHeight = 16;
159 constexpr int kNumCodecTypes = 5;
160
161 constexpr VideoCodecType kCodecList[kNumCodecTypes] = {
162 kVideoCodecGeneric, kVideoCodecVP8, kVideoCodecVP9, kVideoCodecAV1,
163 kVideoCodecH264};
164 const int64_t render_time_ms =
165 rtc::TimeMillis() + prng_.Rand(kMinRenderDelayMs, kMaxRenderDelayMs);
166 const int width = prng_.Rand(kMinWidth, kMaxWidth);
167 const int height = prng_.Rand(kMinHeight, kMaxHeight);
168 const VideoCodecType codec = kCodecList[prng_.Rand(0, kNumCodecTypes - 1)];
169 const uint8_t qp = prng_.Rand<uint8_t>();
170 return std::make_unique<RtcEventFrameDecoded>(render_time_ms, ssrc, width,
171 height, codec, qp);
172 }
173
174 std::unique_ptr<RtcEventProbeClusterCreated>
NewProbeClusterCreated()175 EventGenerator::NewProbeClusterCreated() {
176 constexpr int kMaxBweBps = 20000000;
177 constexpr int kMaxNumProbes = 10000;
178 int id = prng_.Rand(1, kMaxNumProbes);
179 int bitrate_bps = prng_.Rand(0, kMaxBweBps);
180 int min_probes = prng_.Rand(5, 50);
181 int min_bytes = prng_.Rand(500, 50000);
182
183 return std::make_unique<RtcEventProbeClusterCreated>(id, bitrate_bps,
184 min_probes, min_bytes);
185 }
186
187 std::unique_ptr<RtcEventProbeResultFailure>
NewProbeResultFailure()188 EventGenerator::NewProbeResultFailure() {
189 constexpr int kMaxNumProbes = 10000;
190 int id = prng_.Rand(1, kMaxNumProbes);
191 ProbeFailureReason reason = static_cast<ProbeFailureReason>(
192 prng_.Rand(static_cast<uint32_t>(ProbeFailureReason::kLast) - 1));
193
194 return std::make_unique<RtcEventProbeResultFailure>(id, reason);
195 }
196
197 std::unique_ptr<RtcEventProbeResultSuccess>
NewProbeResultSuccess()198 EventGenerator::NewProbeResultSuccess() {
199 constexpr int kMaxBweBps = 20000000;
200 constexpr int kMaxNumProbes = 10000;
201 int id = prng_.Rand(1, kMaxNumProbes);
202 int bitrate_bps = prng_.Rand(0, kMaxBweBps);
203
204 return std::make_unique<RtcEventProbeResultSuccess>(id, bitrate_bps);
205 }
206
207 std::unique_ptr<RtcEventIceCandidatePairConfig>
NewIceCandidatePairConfig()208 EventGenerator::NewIceCandidatePairConfig() {
209 IceCandidateType local_candidate_type = static_cast<IceCandidateType>(
210 prng_.Rand(static_cast<uint32_t>(IceCandidateType::kNumValues) - 1));
211 IceCandidateNetworkType local_network_type =
212 static_cast<IceCandidateNetworkType>(prng_.Rand(
213 static_cast<uint32_t>(IceCandidateNetworkType::kNumValues) - 1));
214 IceCandidatePairAddressFamily local_address_family =
215 static_cast<IceCandidatePairAddressFamily>(prng_.Rand(
216 static_cast<uint32_t>(IceCandidatePairAddressFamily::kNumValues) -
217 1));
218 IceCandidateType remote_candidate_type = static_cast<IceCandidateType>(
219 prng_.Rand(static_cast<uint32_t>(IceCandidateType::kNumValues) - 1));
220 IceCandidatePairAddressFamily remote_address_family =
221 static_cast<IceCandidatePairAddressFamily>(prng_.Rand(
222 static_cast<uint32_t>(IceCandidatePairAddressFamily::kNumValues) -
223 1));
224 IceCandidatePairProtocol protocol_type =
225 static_cast<IceCandidatePairProtocol>(prng_.Rand(
226 static_cast<uint32_t>(IceCandidatePairProtocol::kNumValues) - 1));
227
228 IceCandidatePairDescription desc;
229 desc.local_candidate_type = local_candidate_type;
230 desc.local_relay_protocol = protocol_type;
231 desc.local_network_type = local_network_type;
232 desc.local_address_family = local_address_family;
233 desc.remote_candidate_type = remote_candidate_type;
234 desc.remote_address_family = remote_address_family;
235 desc.candidate_pair_protocol = protocol_type;
236
237 IceCandidatePairConfigType type =
238 static_cast<IceCandidatePairConfigType>(prng_.Rand(
239 static_cast<uint32_t>(IceCandidatePairConfigType::kNumValues) - 1));
240 uint32_t pair_id = prng_.Rand<uint32_t>();
241 return std::make_unique<RtcEventIceCandidatePairConfig>(type, pair_id, desc);
242 }
243
244 std::unique_ptr<RtcEventIceCandidatePair>
NewIceCandidatePair()245 EventGenerator::NewIceCandidatePair() {
246 IceCandidatePairEventType type =
247 static_cast<IceCandidatePairEventType>(prng_.Rand(
248 static_cast<uint32_t>(IceCandidatePairEventType::kNumValues) - 1));
249 uint32_t pair_id = prng_.Rand<uint32_t>();
250 uint32_t transaction_id = prng_.Rand<uint32_t>();
251
252 return std::make_unique<RtcEventIceCandidatePair>(type, pair_id,
253 transaction_id);
254 }
255
NewReportBlock()256 rtcp::ReportBlock EventGenerator::NewReportBlock() {
257 rtcp::ReportBlock report_block;
258 report_block.SetMediaSsrc(prng_.Rand<uint32_t>());
259 report_block.SetFractionLost(prng_.Rand<uint8_t>());
260 // cumulative_lost is a 3-byte signed value.
261 RTC_DCHECK(report_block.SetCumulativeLost(
262 prng_.Rand(-(1 << 23) + 1, (1 << 23) - 1)));
263 report_block.SetExtHighestSeqNum(prng_.Rand<uint32_t>());
264 report_block.SetJitter(prng_.Rand<uint32_t>());
265 report_block.SetLastSr(prng_.Rand<uint32_t>());
266 report_block.SetDelayLastSr(prng_.Rand<uint32_t>());
267 return report_block;
268 }
269
NewSenderReport()270 rtcp::SenderReport EventGenerator::NewSenderReport() {
271 rtcp::SenderReport sender_report;
272 sender_report.SetSenderSsrc(prng_.Rand<uint32_t>());
273 sender_report.SetNtp(NtpTime(prng_.Rand<uint32_t>(), prng_.Rand<uint32_t>()));
274 sender_report.SetRtpTimestamp(prng_.Rand<uint32_t>());
275 sender_report.SetPacketCount(prng_.Rand<uint32_t>());
276 sender_report.SetOctetCount(prng_.Rand<uint32_t>());
277 sender_report.AddReportBlock(NewReportBlock());
278 return sender_report;
279 }
280
NewReceiverReport()281 rtcp::ReceiverReport EventGenerator::NewReceiverReport() {
282 rtcp::ReceiverReport receiver_report;
283 receiver_report.SetSenderSsrc(prng_.Rand<uint32_t>());
284 receiver_report.AddReportBlock(NewReportBlock());
285 return receiver_report;
286 }
287
NewExtendedReports()288 rtcp::ExtendedReports EventGenerator::NewExtendedReports() {
289 rtcp::ExtendedReports extended_report;
290 extended_report.SetSenderSsrc(prng_.Rand<uint32_t>());
291
292 rtcp::Rrtr rrtr;
293 rrtr.SetNtp(NtpTime(prng_.Rand<uint32_t>(), prng_.Rand<uint32_t>()));
294 extended_report.SetRrtr(rrtr);
295
296 rtcp::ReceiveTimeInfo time_info(
297 prng_.Rand<uint32_t>(), prng_.Rand<uint32_t>(), prng_.Rand<uint32_t>());
298 extended_report.AddDlrrItem(time_info);
299
300 rtcp::TargetBitrate target_bitrate;
301 target_bitrate.AddTargetBitrate(/*spatial layer*/ prng_.Rand(0, 3),
302 /*temporal layer*/ prng_.Rand(0, 3),
303 /*bitrate kbps*/ prng_.Rand(0, 50000));
304 target_bitrate.AddTargetBitrate(/*spatial layer*/ prng_.Rand(4, 7),
305 /*temporal layer*/ prng_.Rand(4, 7),
306 /*bitrate kbps*/ prng_.Rand(0, 50000));
307 extended_report.SetTargetBitrate(target_bitrate);
308 return extended_report;
309 }
310
NewNack()311 rtcp::Nack EventGenerator::NewNack() {
312 rtcp::Nack nack;
313 uint16_t base_seq_no = prng_.Rand<uint16_t>();
314 std::vector<uint16_t> nack_list;
315 nack_list.push_back(base_seq_no);
316 for (uint16_t i = 1u; i < 10u; i++) {
317 if (prng_.Rand<bool>())
318 nack_list.push_back(base_seq_no + i);
319 }
320 nack.SetPacketIds(nack_list);
321 return nack;
322 }
323
NewFir()324 rtcp::Fir EventGenerator::NewFir() {
325 rtcp::Fir fir;
326 fir.SetSenderSsrc(prng_.Rand<uint32_t>());
327 fir.AddRequestTo(/*ssrc*/ prng_.Rand<uint32_t>(),
328 /*seq num*/ prng_.Rand<uint8_t>());
329 fir.AddRequestTo(/*ssrc*/ prng_.Rand<uint32_t>(),
330 /*seq num*/ prng_.Rand<uint8_t>());
331 return fir;
332 }
333
NewPli()334 rtcp::Pli EventGenerator::NewPli() {
335 rtcp::Pli pli;
336 pli.SetSenderSsrc(prng_.Rand<uint32_t>());
337 pli.SetMediaSsrc(prng_.Rand<uint32_t>());
338 return pli;
339 }
340
NewTransportFeedback()341 rtcp::TransportFeedback EventGenerator::NewTransportFeedback() {
342 rtcp::TransportFeedback transport_feedback;
343 uint16_t base_seq_no = prng_.Rand<uint16_t>();
344 int64_t base_time_us = prng_.Rand<uint32_t>();
345 transport_feedback.SetBase(base_seq_no, base_time_us);
346 transport_feedback.AddReceivedPacket(base_seq_no, base_time_us);
347 int64_t time_us = base_time_us;
348 for (uint16_t i = 1u; i < 10u; i++) {
349 time_us += prng_.Rand(0, 100000);
350 if (prng_.Rand<bool>()) {
351 transport_feedback.AddReceivedPacket(base_seq_no + i, time_us);
352 }
353 }
354 return transport_feedback;
355 }
356
NewRemb()357 rtcp::Remb EventGenerator::NewRemb() {
358 rtcp::Remb remb;
359 // The remb bitrate is transported as a 16-bit mantissa and an 8-bit exponent.
360 uint64_t bitrate_bps = prng_.Rand(0, (1 << 16) - 1) << prng_.Rand(7);
361 std::vector<uint32_t> ssrcs{prng_.Rand<uint32_t>(), prng_.Rand<uint32_t>()};
362 remb.SetSsrcs(ssrcs);
363 remb.SetBitrateBps(bitrate_bps);
364 return remb;
365 }
366
NewLossNotification()367 rtcp::LossNotification EventGenerator::NewLossNotification() {
368 rtcp::LossNotification loss_notification;
369 const uint16_t last_decoded = prng_.Rand<uint16_t>();
370 const uint16_t last_received =
371 last_decoded + (prng_.Rand<uint16_t>() & 0x7fff);
372 const bool decodability_flag = prng_.Rand<bool>();
373 EXPECT_TRUE(
374 loss_notification.Set(last_decoded, last_received, decodability_flag));
375 return loss_notification;
376 }
377
NewRouteChange()378 std::unique_ptr<RtcEventRouteChange> EventGenerator::NewRouteChange() {
379 return std::make_unique<RtcEventRouteChange>(prng_.Rand<bool>(),
380 prng_.Rand(0, 128));
381 }
382
NewRemoteEstimate()383 std::unique_ptr<RtcEventRemoteEstimate> EventGenerator::NewRemoteEstimate() {
384 return std::make_unique<RtcEventRemoteEstimate>(
385 DataRate::KilobitsPerSec(prng_.Rand(0, 100000)),
386 DataRate::KilobitsPerSec(prng_.Rand(0, 100000)));
387 }
388
389 std::unique_ptr<RtcEventRtcpPacketIncoming>
NewRtcpPacketIncoming()390 EventGenerator::NewRtcpPacketIncoming() {
391 enum class SupportedRtcpTypes {
392 kSenderReport = 0,
393 kReceiverReport,
394 kExtendedReports,
395 kFir,
396 kPli,
397 kNack,
398 kRemb,
399 kTransportFeedback,
400 kNumValues
401 };
402 SupportedRtcpTypes type = static_cast<SupportedRtcpTypes>(
403 prng_.Rand(0, static_cast<int>(SupportedRtcpTypes::kNumValues) - 1));
404 switch (type) {
405 case SupportedRtcpTypes::kSenderReport: {
406 rtcp::SenderReport sender_report = NewSenderReport();
407 rtc::Buffer buffer = sender_report.Build();
408 return std::make_unique<RtcEventRtcpPacketIncoming>(buffer);
409 }
410 case SupportedRtcpTypes::kReceiverReport: {
411 rtcp::ReceiverReport receiver_report = NewReceiverReport();
412 rtc::Buffer buffer = receiver_report.Build();
413 return std::make_unique<RtcEventRtcpPacketIncoming>(buffer);
414 }
415 case SupportedRtcpTypes::kExtendedReports: {
416 rtcp::ExtendedReports extended_report = NewExtendedReports();
417 rtc::Buffer buffer = extended_report.Build();
418 return std::make_unique<RtcEventRtcpPacketIncoming>(buffer);
419 }
420 case SupportedRtcpTypes::kFir: {
421 rtcp::Fir fir = NewFir();
422 rtc::Buffer buffer = fir.Build();
423 return std::make_unique<RtcEventRtcpPacketIncoming>(buffer);
424 }
425 case SupportedRtcpTypes::kPli: {
426 rtcp::Pli pli = NewPli();
427 rtc::Buffer buffer = pli.Build();
428 return std::make_unique<RtcEventRtcpPacketIncoming>(buffer);
429 }
430 case SupportedRtcpTypes::kNack: {
431 rtcp::Nack nack = NewNack();
432 rtc::Buffer buffer = nack.Build();
433 return std::make_unique<RtcEventRtcpPacketIncoming>(buffer);
434 }
435 case SupportedRtcpTypes::kRemb: {
436 rtcp::Remb remb = NewRemb();
437 rtc::Buffer buffer = remb.Build();
438 return std::make_unique<RtcEventRtcpPacketIncoming>(buffer);
439 }
440 case SupportedRtcpTypes::kTransportFeedback: {
441 rtcp::TransportFeedback transport_feedback = NewTransportFeedback();
442 rtc::Buffer buffer = transport_feedback.Build();
443 return std::make_unique<RtcEventRtcpPacketIncoming>(buffer);
444 }
445 default:
446 RTC_NOTREACHED();
447 rtc::Buffer buffer;
448 return std::make_unique<RtcEventRtcpPacketIncoming>(buffer);
449 }
450 }
451
452 std::unique_ptr<RtcEventRtcpPacketOutgoing>
NewRtcpPacketOutgoing()453 EventGenerator::NewRtcpPacketOutgoing() {
454 enum class SupportedRtcpTypes {
455 kSenderReport = 0,
456 kReceiverReport,
457 kExtendedReports,
458 kFir,
459 kPli,
460 kNack,
461 kRemb,
462 kTransportFeedback,
463 kNumValues
464 };
465 SupportedRtcpTypes type = static_cast<SupportedRtcpTypes>(
466 prng_.Rand(0, static_cast<int>(SupportedRtcpTypes::kNumValues) - 1));
467 switch (type) {
468 case SupportedRtcpTypes::kSenderReport: {
469 rtcp::SenderReport sender_report = NewSenderReport();
470 rtc::Buffer buffer = sender_report.Build();
471 return std::make_unique<RtcEventRtcpPacketOutgoing>(buffer);
472 }
473 case SupportedRtcpTypes::kReceiverReport: {
474 rtcp::ReceiverReport receiver_report = NewReceiverReport();
475 rtc::Buffer buffer = receiver_report.Build();
476 return std::make_unique<RtcEventRtcpPacketOutgoing>(buffer);
477 }
478 case SupportedRtcpTypes::kExtendedReports: {
479 rtcp::ExtendedReports extended_report = NewExtendedReports();
480 rtc::Buffer buffer = extended_report.Build();
481 return std::make_unique<RtcEventRtcpPacketOutgoing>(buffer);
482 }
483 case SupportedRtcpTypes::kFir: {
484 rtcp::Fir fir = NewFir();
485 rtc::Buffer buffer = fir.Build();
486 return std::make_unique<RtcEventRtcpPacketOutgoing>(buffer);
487 }
488 case SupportedRtcpTypes::kPli: {
489 rtcp::Pli pli = NewPli();
490 rtc::Buffer buffer = pli.Build();
491 return std::make_unique<RtcEventRtcpPacketOutgoing>(buffer);
492 }
493 case SupportedRtcpTypes::kNack: {
494 rtcp::Nack nack = NewNack();
495 rtc::Buffer buffer = nack.Build();
496 return std::make_unique<RtcEventRtcpPacketOutgoing>(buffer);
497 }
498 case SupportedRtcpTypes::kRemb: {
499 rtcp::Remb remb = NewRemb();
500 rtc::Buffer buffer = remb.Build();
501 return std::make_unique<RtcEventRtcpPacketOutgoing>(buffer);
502 }
503 case SupportedRtcpTypes::kTransportFeedback: {
504 rtcp::TransportFeedback transport_feedback = NewTransportFeedback();
505 rtc::Buffer buffer = transport_feedback.Build();
506 return std::make_unique<RtcEventRtcpPacketOutgoing>(buffer);
507 }
508 default:
509 RTC_NOTREACHED();
510 rtc::Buffer buffer;
511 return std::make_unique<RtcEventRtcpPacketOutgoing>(buffer);
512 }
513 }
514
515 std::unique_ptr<RtcEventGenericPacketSent>
NewGenericPacketSent()516 EventGenerator::NewGenericPacketSent() {
517 return std::make_unique<RtcEventGenericPacketSent>(
518 sent_packet_number_++, prng_.Rand(40, 50), prng_.Rand(0, 150),
519 prng_.Rand(0, 1000));
520 }
521 std::unique_ptr<RtcEventGenericPacketReceived>
NewGenericPacketReceived()522 EventGenerator::NewGenericPacketReceived() {
523 return std::make_unique<RtcEventGenericPacketReceived>(
524 received_packet_number_++, prng_.Rand(40, 250));
525 }
526 std::unique_ptr<RtcEventGenericAckReceived>
NewGenericAckReceived()527 EventGenerator::NewGenericAckReceived() {
528 absl::optional<int64_t> receive_timestamp = absl::nullopt;
529 if (prng_.Rand(0, 2) > 0) {
530 receive_timestamp = prng_.Rand(0, 100000);
531 }
532 AckedPacket packet = {prng_.Rand(40, 250), receive_timestamp};
533 return std::move(RtcEventGenericAckReceived::CreateLogs(
534 received_packet_number_++, std::vector<AckedPacket>{packet})[0]);
535 }
536
RandomizeRtpPacket(size_t payload_size,size_t padding_size,uint32_t ssrc,const RtpHeaderExtensionMap & extension_map,RtpPacket * rtp_packet,bool all_configured_exts)537 void EventGenerator::RandomizeRtpPacket(
538 size_t payload_size,
539 size_t padding_size,
540 uint32_t ssrc,
541 const RtpHeaderExtensionMap& extension_map,
542 RtpPacket* rtp_packet,
543 bool all_configured_exts) {
544 constexpr int kMaxPayloadType = 127;
545 rtp_packet->SetPayloadType(prng_.Rand(kMaxPayloadType));
546 rtp_packet->SetMarker(prng_.Rand<bool>());
547 rtp_packet->SetSequenceNumber(prng_.Rand<uint16_t>());
548 rtp_packet->SetSsrc(ssrc);
549 rtp_packet->SetTimestamp(prng_.Rand<uint32_t>());
550
551 uint32_t csrcs_count = prng_.Rand(0, kMaxCsrcs);
552 std::vector<uint32_t> csrcs;
553 for (size_t i = 0; i < csrcs_count; i++) {
554 csrcs.push_back(prng_.Rand<uint32_t>());
555 }
556 rtp_packet->SetCsrcs(csrcs);
557
558 if (extension_map.IsRegistered(TransmissionOffset::kId) &&
559 (all_configured_exts || prng_.Rand<bool>())) {
560 rtp_packet->SetExtension<TransmissionOffset>(prng_.Rand(0x00ffffff));
561 }
562
563 if (extension_map.IsRegistered(AudioLevel::kId) &&
564 (all_configured_exts || prng_.Rand<bool>())) {
565 rtp_packet->SetExtension<AudioLevel>(prng_.Rand<bool>(), prng_.Rand(127));
566 }
567
568 if (extension_map.IsRegistered(AbsoluteSendTime::kId) &&
569 (all_configured_exts || prng_.Rand<bool>())) {
570 rtp_packet->SetExtension<AbsoluteSendTime>(prng_.Rand(0x00ffffff));
571 }
572
573 if (extension_map.IsRegistered(VideoOrientation::kId) &&
574 (all_configured_exts || prng_.Rand<bool>())) {
575 rtp_packet->SetExtension<VideoOrientation>(prng_.Rand(3));
576 }
577
578 if (extension_map.IsRegistered(TransportSequenceNumber::kId) &&
579 (all_configured_exts || prng_.Rand<bool>())) {
580 rtp_packet->SetExtension<TransportSequenceNumber>(prng_.Rand<uint16_t>());
581 }
582
583 RTC_CHECK_LE(rtp_packet->headers_size() + payload_size, IP_PACKET_SIZE);
584
585 uint8_t* payload = rtp_packet->AllocatePayload(payload_size);
586 RTC_DCHECK(payload != nullptr);
587 for (size_t i = 0; i < payload_size; i++) {
588 payload[i] = prng_.Rand<uint8_t>();
589 }
590 RTC_CHECK(rtp_packet->SetPadding(padding_size));
591 }
592
NewRtpPacketIncoming(uint32_t ssrc,const RtpHeaderExtensionMap & extension_map,bool all_configured_exts)593 std::unique_ptr<RtcEventRtpPacketIncoming> EventGenerator::NewRtpPacketIncoming(
594 uint32_t ssrc,
595 const RtpHeaderExtensionMap& extension_map,
596 bool all_configured_exts) {
597 constexpr size_t kMaxPaddingLength = 224;
598 const bool padding = prng_.Rand(0, 9) == 0; // Let padding be 10% probable.
599 const size_t padding_size = !padding ? 0u : prng_.Rand(0u, kMaxPaddingLength);
600
601 // 12 bytes RTP header, 4 bytes for 0xBEDE + alignment, 4 bytes per CSRC.
602 constexpr size_t kMaxHeaderSize =
603 16 + 4 * kMaxCsrcs + kMaxExtensionSizeBytes * kMaxNumExtensions;
604
605 // In principle, a packet can contain both padding and other payload.
606 // Currently, RTC eventlog encoder-parser can only maintain padding length if
607 // packet is full padding.
608 // TODO(webrtc:9730): Remove the deterministic logic for padding_size > 0.
609 size_t payload_size =
610 padding_size > 0 ? 0
611 : prng_.Rand(0u, static_cast<uint32_t>(IP_PACKET_SIZE -
612 1 - padding_size -
613 kMaxHeaderSize));
614
615 RtpPacketReceived rtp_packet(&extension_map);
616 RandomizeRtpPacket(payload_size, padding_size, ssrc, extension_map,
617 &rtp_packet, all_configured_exts);
618
619 return std::make_unique<RtcEventRtpPacketIncoming>(rtp_packet);
620 }
621
NewRtpPacketOutgoing(uint32_t ssrc,const RtpHeaderExtensionMap & extension_map,bool all_configured_exts)622 std::unique_ptr<RtcEventRtpPacketOutgoing> EventGenerator::NewRtpPacketOutgoing(
623 uint32_t ssrc,
624 const RtpHeaderExtensionMap& extension_map,
625 bool all_configured_exts) {
626 constexpr size_t kMaxPaddingLength = 224;
627 const bool padding = prng_.Rand(0, 9) == 0; // Let padding be 10% probable.
628 const size_t padding_size = !padding ? 0u : prng_.Rand(0u, kMaxPaddingLength);
629
630 // 12 bytes RTP header, 4 bytes for 0xBEDE + alignment, 4 bytes per CSRC.
631 constexpr size_t kMaxHeaderSize =
632 16 + 4 * kMaxCsrcs + kMaxExtensionSizeBytes * kMaxNumExtensions;
633
634 // In principle,a packet can contain both padding and other payload.
635 // Currently, RTC eventlog encoder-parser can only maintain padding length if
636 // packet is full padding.
637 // TODO(webrtc:9730): Remove the deterministic logic for padding_size > 0.
638 size_t payload_size =
639 padding_size > 0 ? 0
640 : prng_.Rand(0u, static_cast<uint32_t>(IP_PACKET_SIZE -
641 1 - padding_size -
642 kMaxHeaderSize));
643
644 RtpPacketToSend rtp_packet(&extension_map,
645 kMaxHeaderSize + payload_size + padding_size);
646 RandomizeRtpPacket(payload_size, padding_size, ssrc, extension_map,
647 &rtp_packet, all_configured_exts);
648
649 int probe_cluster_id = prng_.Rand(0, 100000);
650 return std::make_unique<RtcEventRtpPacketOutgoing>(rtp_packet,
651 probe_cluster_id);
652 }
653
NewRtpHeaderExtensionMap(bool configure_all)654 RtpHeaderExtensionMap EventGenerator::NewRtpHeaderExtensionMap(
655 bool configure_all) {
656 RtpHeaderExtensionMap extension_map;
657 std::vector<int> id(RtpExtension::kOneByteHeaderExtensionMaxId -
658 RtpExtension::kMinId + 1);
659 std::iota(id.begin(), id.end(), RtpExtension::kMinId);
660 ShuffleInPlace(&prng_, rtc::ArrayView<int>(id));
661
662 if (configure_all || prng_.Rand<bool>()) {
663 extension_map.Register<AudioLevel>(id[0]);
664 }
665 if (configure_all || prng_.Rand<bool>()) {
666 extension_map.Register<TransmissionOffset>(id[1]);
667 }
668 if (configure_all || prng_.Rand<bool>()) {
669 extension_map.Register<AbsoluteSendTime>(id[2]);
670 }
671 if (configure_all || prng_.Rand<bool>()) {
672 extension_map.Register<VideoOrientation>(id[3]);
673 }
674 if (configure_all || prng_.Rand<bool>()) {
675 extension_map.Register<TransportSequenceNumber>(id[4]);
676 }
677
678 return extension_map;
679 }
680
681 std::unique_ptr<RtcEventAudioReceiveStreamConfig>
NewAudioReceiveStreamConfig(uint32_t ssrc,const RtpHeaderExtensionMap & extensions)682 EventGenerator::NewAudioReceiveStreamConfig(
683 uint32_t ssrc,
684 const RtpHeaderExtensionMap& extensions) {
685 auto config = std::make_unique<rtclog::StreamConfig>();
686 // Add SSRCs for the stream.
687 config->remote_ssrc = ssrc;
688 config->local_ssrc = prng_.Rand<uint32_t>();
689 // Add header extensions.
690 for (size_t i = 0; i < kMaxNumExtensions; i++) {
691 uint8_t id = extensions.GetId(kExtensions[i].type);
692 if (id != RtpHeaderExtensionMap::kInvalidId) {
693 config->rtp_extensions.emplace_back(kExtensions[i].name, id);
694 }
695 }
696
697 return std::make_unique<RtcEventAudioReceiveStreamConfig>(std::move(config));
698 }
699
700 std::unique_ptr<RtcEventAudioSendStreamConfig>
NewAudioSendStreamConfig(uint32_t ssrc,const RtpHeaderExtensionMap & extensions)701 EventGenerator::NewAudioSendStreamConfig(
702 uint32_t ssrc,
703 const RtpHeaderExtensionMap& extensions) {
704 auto config = std::make_unique<rtclog::StreamConfig>();
705 // Add SSRC to the stream.
706 config->local_ssrc = ssrc;
707 // Add header extensions.
708 for (size_t i = 0; i < kMaxNumExtensions; i++) {
709 uint8_t id = extensions.GetId(kExtensions[i].type);
710 if (id != RtpHeaderExtensionMap::kInvalidId) {
711 config->rtp_extensions.emplace_back(kExtensions[i].name, id);
712 }
713 }
714 return std::make_unique<RtcEventAudioSendStreamConfig>(std::move(config));
715 }
716
717 std::unique_ptr<RtcEventVideoReceiveStreamConfig>
NewVideoReceiveStreamConfig(uint32_t ssrc,const RtpHeaderExtensionMap & extensions)718 EventGenerator::NewVideoReceiveStreamConfig(
719 uint32_t ssrc,
720 const RtpHeaderExtensionMap& extensions) {
721 auto config = std::make_unique<rtclog::StreamConfig>();
722
723 // Add SSRCs for the stream.
724 config->remote_ssrc = ssrc;
725 config->local_ssrc = prng_.Rand<uint32_t>();
726 // Add extensions and settings for RTCP.
727 config->rtcp_mode =
728 prng_.Rand<bool>() ? RtcpMode::kCompound : RtcpMode::kReducedSize;
729 config->remb = prng_.Rand<bool>();
730 config->rtx_ssrc = prng_.Rand<uint32_t>();
731 config->codecs.emplace_back(prng_.Rand<bool>() ? "VP8" : "H264",
732 prng_.Rand(127), prng_.Rand(127));
733 // Add header extensions.
734 for (size_t i = 0; i < kMaxNumExtensions; i++) {
735 uint8_t id = extensions.GetId(kExtensions[i].type);
736 if (id != RtpHeaderExtensionMap::kInvalidId) {
737 config->rtp_extensions.emplace_back(kExtensions[i].name, id);
738 }
739 }
740 return std::make_unique<RtcEventVideoReceiveStreamConfig>(std::move(config));
741 }
742
743 std::unique_ptr<RtcEventVideoSendStreamConfig>
NewVideoSendStreamConfig(uint32_t ssrc,const RtpHeaderExtensionMap & extensions)744 EventGenerator::NewVideoSendStreamConfig(
745 uint32_t ssrc,
746 const RtpHeaderExtensionMap& extensions) {
747 auto config = std::make_unique<rtclog::StreamConfig>();
748
749 config->codecs.emplace_back(prng_.Rand<bool>() ? "VP8" : "H264",
750 prng_.Rand(127), prng_.Rand(127));
751 config->local_ssrc = ssrc;
752 config->rtx_ssrc = prng_.Rand<uint32_t>();
753 // Add header extensions.
754 for (size_t i = 0; i < kMaxNumExtensions; i++) {
755 uint8_t id = extensions.GetId(kExtensions[i].type);
756 if (id != RtpHeaderExtensionMap::kInvalidId) {
757 config->rtp_extensions.emplace_back(kExtensions[i].name, id);
758 }
759 }
760 return std::make_unique<RtcEventVideoSendStreamConfig>(std::move(config));
761 }
762
VerifyLoggedAlrStateEvent(const RtcEventAlrState & original_event,const LoggedAlrStateEvent & logged_event) const763 void EventVerifier::VerifyLoggedAlrStateEvent(
764 const RtcEventAlrState& original_event,
765 const LoggedAlrStateEvent& logged_event) const {
766 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
767 EXPECT_EQ(original_event.in_alr(), logged_event.in_alr);
768 }
769
VerifyLoggedAudioPlayoutEvent(const RtcEventAudioPlayout & original_event,const LoggedAudioPlayoutEvent & logged_event) const770 void EventVerifier::VerifyLoggedAudioPlayoutEvent(
771 const RtcEventAudioPlayout& original_event,
772 const LoggedAudioPlayoutEvent& logged_event) const {
773 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
774 EXPECT_EQ(original_event.ssrc(), logged_event.ssrc);
775 }
776
VerifyLoggedAudioNetworkAdaptationEvent(const RtcEventAudioNetworkAdaptation & original_event,const LoggedAudioNetworkAdaptationEvent & logged_event) const777 void EventVerifier::VerifyLoggedAudioNetworkAdaptationEvent(
778 const RtcEventAudioNetworkAdaptation& original_event,
779 const LoggedAudioNetworkAdaptationEvent& logged_event) const {
780 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
781
782 EXPECT_EQ(original_event.config().bitrate_bps,
783 logged_event.config.bitrate_bps);
784 EXPECT_EQ(original_event.config().enable_dtx, logged_event.config.enable_dtx);
785 EXPECT_EQ(original_event.config().enable_fec, logged_event.config.enable_fec);
786 EXPECT_EQ(original_event.config().frame_length_ms,
787 logged_event.config.frame_length_ms);
788 EXPECT_EQ(original_event.config().num_channels,
789 logged_event.config.num_channels);
790
791 // uplink_packet_loss_fraction
792 ASSERT_EQ(original_event.config().uplink_packet_loss_fraction.has_value(),
793 logged_event.config.uplink_packet_loss_fraction.has_value());
794 if (original_event.config().uplink_packet_loss_fraction.has_value()) {
795 const float original =
796 original_event.config().uplink_packet_loss_fraction.value();
797 const float logged =
798 logged_event.config.uplink_packet_loss_fraction.value();
799 const float uplink_packet_loss_fraction_delta = std::abs(original - logged);
800 EXPECT_LE(uplink_packet_loss_fraction_delta, 0.0001f);
801 }
802 }
803
VerifyLoggedBweDelayBasedUpdate(const RtcEventBweUpdateDelayBased & original_event,const LoggedBweDelayBasedUpdate & logged_event) const804 void EventVerifier::VerifyLoggedBweDelayBasedUpdate(
805 const RtcEventBweUpdateDelayBased& original_event,
806 const LoggedBweDelayBasedUpdate& logged_event) const {
807 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
808 EXPECT_EQ(original_event.bitrate_bps(), logged_event.bitrate_bps);
809 EXPECT_EQ(original_event.detector_state(), logged_event.detector_state);
810 }
811
VerifyLoggedBweLossBasedUpdate(const RtcEventBweUpdateLossBased & original_event,const LoggedBweLossBasedUpdate & logged_event) const812 void EventVerifier::VerifyLoggedBweLossBasedUpdate(
813 const RtcEventBweUpdateLossBased& original_event,
814 const LoggedBweLossBasedUpdate& logged_event) const {
815 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
816 EXPECT_EQ(original_event.bitrate_bps(), logged_event.bitrate_bps);
817 EXPECT_EQ(original_event.fraction_loss(), logged_event.fraction_lost);
818 EXPECT_EQ(original_event.total_packets(), logged_event.expected_packets);
819 }
820
VerifyLoggedBweProbeClusterCreatedEvent(const RtcEventProbeClusterCreated & original_event,const LoggedBweProbeClusterCreatedEvent & logged_event) const821 void EventVerifier::VerifyLoggedBweProbeClusterCreatedEvent(
822 const RtcEventProbeClusterCreated& original_event,
823 const LoggedBweProbeClusterCreatedEvent& logged_event) const {
824 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
825 EXPECT_EQ(original_event.id(), logged_event.id);
826 EXPECT_EQ(original_event.bitrate_bps(), logged_event.bitrate_bps);
827 EXPECT_EQ(original_event.min_probes(), logged_event.min_packets);
828 EXPECT_EQ(original_event.min_bytes(), logged_event.min_bytes);
829 }
830
VerifyLoggedBweProbeFailureEvent(const RtcEventProbeResultFailure & original_event,const LoggedBweProbeFailureEvent & logged_event) const831 void EventVerifier::VerifyLoggedBweProbeFailureEvent(
832 const RtcEventProbeResultFailure& original_event,
833 const LoggedBweProbeFailureEvent& logged_event) const {
834 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
835 EXPECT_EQ(original_event.id(), logged_event.id);
836 EXPECT_EQ(original_event.failure_reason(), logged_event.failure_reason);
837 }
838
VerifyLoggedBweProbeSuccessEvent(const RtcEventProbeResultSuccess & original_event,const LoggedBweProbeSuccessEvent & logged_event) const839 void EventVerifier::VerifyLoggedBweProbeSuccessEvent(
840 const RtcEventProbeResultSuccess& original_event,
841 const LoggedBweProbeSuccessEvent& logged_event) const {
842 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
843 EXPECT_EQ(original_event.id(), logged_event.id);
844 EXPECT_EQ(original_event.bitrate_bps(), logged_event.bitrate_bps);
845 }
846
VerifyLoggedDtlsTransportState(const RtcEventDtlsTransportState & original_event,const LoggedDtlsTransportState & logged_event) const847 void EventVerifier::VerifyLoggedDtlsTransportState(
848 const RtcEventDtlsTransportState& original_event,
849 const LoggedDtlsTransportState& logged_event) const {
850 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
851 EXPECT_EQ(original_event.dtls_transport_state(),
852 logged_event.dtls_transport_state);
853 }
854
VerifyLoggedDtlsWritableState(const RtcEventDtlsWritableState & original_event,const LoggedDtlsWritableState & logged_event) const855 void EventVerifier::VerifyLoggedDtlsWritableState(
856 const RtcEventDtlsWritableState& original_event,
857 const LoggedDtlsWritableState& logged_event) const {
858 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
859 EXPECT_EQ(original_event.writable(), logged_event.writable);
860 }
861
VerifyLoggedFrameDecoded(const RtcEventFrameDecoded & original_event,const LoggedFrameDecoded & logged_event) const862 void EventVerifier::VerifyLoggedFrameDecoded(
863 const RtcEventFrameDecoded& original_event,
864 const LoggedFrameDecoded& logged_event) const {
865 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
866 EXPECT_EQ(original_event.ssrc(), logged_event.ssrc);
867 EXPECT_EQ(original_event.render_time_ms(), logged_event.render_time_ms);
868 EXPECT_EQ(original_event.width(), logged_event.width);
869 EXPECT_EQ(original_event.height(), logged_event.height);
870 EXPECT_EQ(original_event.codec(), logged_event.codec);
871 EXPECT_EQ(original_event.qp(), logged_event.qp);
872 }
873
VerifyLoggedIceCandidatePairConfig(const RtcEventIceCandidatePairConfig & original_event,const LoggedIceCandidatePairConfig & logged_event) const874 void EventVerifier::VerifyLoggedIceCandidatePairConfig(
875 const RtcEventIceCandidatePairConfig& original_event,
876 const LoggedIceCandidatePairConfig& logged_event) const {
877 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
878
879 EXPECT_EQ(original_event.type(), logged_event.type);
880 EXPECT_EQ(original_event.candidate_pair_id(), logged_event.candidate_pair_id);
881 EXPECT_EQ(original_event.candidate_pair_desc().local_candidate_type,
882 logged_event.local_candidate_type);
883 EXPECT_EQ(original_event.candidate_pair_desc().local_relay_protocol,
884 logged_event.local_relay_protocol);
885 EXPECT_EQ(original_event.candidate_pair_desc().local_network_type,
886 logged_event.local_network_type);
887 EXPECT_EQ(original_event.candidate_pair_desc().local_address_family,
888 logged_event.local_address_family);
889 EXPECT_EQ(original_event.candidate_pair_desc().remote_candidate_type,
890 logged_event.remote_candidate_type);
891 EXPECT_EQ(original_event.candidate_pair_desc().remote_address_family,
892 logged_event.remote_address_family);
893 EXPECT_EQ(original_event.candidate_pair_desc().candidate_pair_protocol,
894 logged_event.candidate_pair_protocol);
895 }
896
VerifyLoggedIceCandidatePairEvent(const RtcEventIceCandidatePair & original_event,const LoggedIceCandidatePairEvent & logged_event) const897 void EventVerifier::VerifyLoggedIceCandidatePairEvent(
898 const RtcEventIceCandidatePair& original_event,
899 const LoggedIceCandidatePairEvent& logged_event) const {
900 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
901
902 EXPECT_EQ(original_event.type(), logged_event.type);
903 EXPECT_EQ(original_event.candidate_pair_id(), logged_event.candidate_pair_id);
904 if (encoding_type_ == RtcEventLog::EncodingType::NewFormat) {
905 EXPECT_EQ(original_event.transaction_id(), logged_event.transaction_id);
906 }
907 }
908
VerifyLoggedRtpHeader(const RtpPacket & original_header,const RTPHeader & logged_header)909 void VerifyLoggedRtpHeader(const RtpPacket& original_header,
910 const RTPHeader& logged_header) {
911 // Standard RTP header.
912 EXPECT_EQ(original_header.Marker(), logged_header.markerBit);
913 EXPECT_EQ(original_header.PayloadType(), logged_header.payloadType);
914 EXPECT_EQ(original_header.SequenceNumber(), logged_header.sequenceNumber);
915 EXPECT_EQ(original_header.Timestamp(), logged_header.timestamp);
916 EXPECT_EQ(original_header.Ssrc(), logged_header.ssrc);
917
918 EXPECT_EQ(original_header.headers_size(), logged_header.headerLength);
919
920 // TransmissionOffset header extension.
921 ASSERT_EQ(original_header.HasExtension<TransmissionOffset>(),
922 logged_header.extension.hasTransmissionTimeOffset);
923 if (logged_header.extension.hasTransmissionTimeOffset) {
924 int32_t offset;
925 ASSERT_TRUE(original_header.GetExtension<TransmissionOffset>(&offset));
926 EXPECT_EQ(offset, logged_header.extension.transmissionTimeOffset);
927 }
928
929 // AbsoluteSendTime header extension.
930 ASSERT_EQ(original_header.HasExtension<AbsoluteSendTime>(),
931 logged_header.extension.hasAbsoluteSendTime);
932 if (logged_header.extension.hasAbsoluteSendTime) {
933 uint32_t sendtime;
934 ASSERT_TRUE(original_header.GetExtension<AbsoluteSendTime>(&sendtime));
935 EXPECT_EQ(sendtime, logged_header.extension.absoluteSendTime);
936 }
937
938 // TransportSequenceNumber header extension.
939 ASSERT_EQ(original_header.HasExtension<TransportSequenceNumber>(),
940 logged_header.extension.hasTransportSequenceNumber);
941 if (logged_header.extension.hasTransportSequenceNumber) {
942 uint16_t seqnum;
943 ASSERT_TRUE(original_header.GetExtension<TransportSequenceNumber>(&seqnum));
944 EXPECT_EQ(seqnum, logged_header.extension.transportSequenceNumber);
945 }
946
947 // AudioLevel header extension.
948 ASSERT_EQ(original_header.HasExtension<AudioLevel>(),
949 logged_header.extension.hasAudioLevel);
950 if (logged_header.extension.hasAudioLevel) {
951 bool voice_activity;
952 uint8_t audio_level;
953 ASSERT_TRUE(original_header.GetExtension<AudioLevel>(&voice_activity,
954 &audio_level));
955 EXPECT_EQ(voice_activity, logged_header.extension.voiceActivity);
956 EXPECT_EQ(audio_level, logged_header.extension.audioLevel);
957 }
958
959 // VideoOrientation header extension.
960 ASSERT_EQ(original_header.HasExtension<VideoOrientation>(),
961 logged_header.extension.hasVideoRotation);
962 if (logged_header.extension.hasVideoRotation) {
963 uint8_t rotation;
964 ASSERT_TRUE(original_header.GetExtension<VideoOrientation>(&rotation));
965 EXPECT_EQ(ConvertCVOByteToVideoRotation(rotation),
966 logged_header.extension.videoRotation);
967 }
968 }
969
VerifyLoggedRouteChangeEvent(const RtcEventRouteChange & original_event,const LoggedRouteChangeEvent & logged_event) const970 void EventVerifier::VerifyLoggedRouteChangeEvent(
971 const RtcEventRouteChange& original_event,
972 const LoggedRouteChangeEvent& logged_event) const {
973 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
974 EXPECT_EQ(original_event.connected(), logged_event.connected);
975 EXPECT_EQ(original_event.overhead(), logged_event.overhead);
976 }
977
VerifyLoggedRemoteEstimateEvent(const RtcEventRemoteEstimate & original_event,const LoggedRemoteEstimateEvent & logged_event) const978 void EventVerifier::VerifyLoggedRemoteEstimateEvent(
979 const RtcEventRemoteEstimate& original_event,
980 const LoggedRemoteEstimateEvent& logged_event) const {
981 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
982 EXPECT_EQ(original_event.link_capacity_lower_,
983 logged_event.link_capacity_lower);
984 EXPECT_EQ(original_event.link_capacity_upper_,
985 logged_event.link_capacity_upper);
986 }
987
VerifyLoggedRtpPacketIncoming(const RtcEventRtpPacketIncoming & original_event,const LoggedRtpPacketIncoming & logged_event) const988 void EventVerifier::VerifyLoggedRtpPacketIncoming(
989 const RtcEventRtpPacketIncoming& original_event,
990 const LoggedRtpPacketIncoming& logged_event) const {
991 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
992
993 EXPECT_EQ(original_event.header().headers_size(),
994 logged_event.rtp.header_length);
995
996 EXPECT_EQ(original_event.packet_length(), logged_event.rtp.total_length);
997
998 // Currently, RTC eventlog encoder-parser can only maintain padding length
999 // if packet is full padding.
1000 EXPECT_EQ(original_event.padding_length(),
1001 logged_event.rtp.header.paddingLength);
1002
1003 VerifyLoggedRtpHeader(original_event.header(), logged_event.rtp.header);
1004 }
1005
VerifyLoggedRtpPacketOutgoing(const RtcEventRtpPacketOutgoing & original_event,const LoggedRtpPacketOutgoing & logged_event) const1006 void EventVerifier::VerifyLoggedRtpPacketOutgoing(
1007 const RtcEventRtpPacketOutgoing& original_event,
1008 const LoggedRtpPacketOutgoing& logged_event) const {
1009 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
1010
1011 EXPECT_EQ(original_event.header().headers_size(),
1012 logged_event.rtp.header_length);
1013
1014 EXPECT_EQ(original_event.packet_length(), logged_event.rtp.total_length);
1015
1016 // Currently, RTC eventlog encoder-parser can only maintain padding length
1017 // if packet is full padding.
1018 EXPECT_EQ(original_event.padding_length(),
1019 logged_event.rtp.header.paddingLength);
1020
1021 // TODO(terelius): Probe cluster ID isn't parsed, used or tested. Unless
1022 // someone has a strong reason to keep it, it'll be removed.
1023
1024 VerifyLoggedRtpHeader(original_event.header(), logged_event.rtp.header);
1025 }
1026
VerifyLoggedGenericPacketSent(const RtcEventGenericPacketSent & original_event,const LoggedGenericPacketSent & logged_event) const1027 void EventVerifier::VerifyLoggedGenericPacketSent(
1028 const RtcEventGenericPacketSent& original_event,
1029 const LoggedGenericPacketSent& logged_event) const {
1030 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
1031 EXPECT_EQ(original_event.packet_number(), logged_event.packet_number);
1032 EXPECT_EQ(original_event.overhead_length(), logged_event.overhead_length);
1033 EXPECT_EQ(original_event.payload_length(), logged_event.payload_length);
1034 EXPECT_EQ(original_event.padding_length(), logged_event.padding_length);
1035 }
1036
VerifyLoggedGenericPacketReceived(const RtcEventGenericPacketReceived & original_event,const LoggedGenericPacketReceived & logged_event) const1037 void EventVerifier::VerifyLoggedGenericPacketReceived(
1038 const RtcEventGenericPacketReceived& original_event,
1039 const LoggedGenericPacketReceived& logged_event) const {
1040 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
1041 EXPECT_EQ(original_event.packet_number(), logged_event.packet_number);
1042 EXPECT_EQ(static_cast<int>(original_event.packet_length()),
1043 logged_event.packet_length);
1044 }
1045
VerifyLoggedGenericAckReceived(const RtcEventGenericAckReceived & original_event,const LoggedGenericAckReceived & logged_event) const1046 void EventVerifier::VerifyLoggedGenericAckReceived(
1047 const RtcEventGenericAckReceived& original_event,
1048 const LoggedGenericAckReceived& logged_event) const {
1049 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
1050 EXPECT_EQ(original_event.packet_number(), logged_event.packet_number);
1051 EXPECT_EQ(original_event.acked_packet_number(),
1052 logged_event.acked_packet_number);
1053 EXPECT_EQ(original_event.receive_acked_packet_time_ms(),
1054 logged_event.receive_acked_packet_time_ms);
1055 }
1056
VerifyLoggedRtcpPacketIncoming(const RtcEventRtcpPacketIncoming & original_event,const LoggedRtcpPacketIncoming & logged_event) const1057 void EventVerifier::VerifyLoggedRtcpPacketIncoming(
1058 const RtcEventRtcpPacketIncoming& original_event,
1059 const LoggedRtcpPacketIncoming& logged_event) const {
1060 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
1061
1062 ASSERT_EQ(original_event.packet().size(), logged_event.rtcp.raw_data.size());
1063 EXPECT_EQ(
1064 memcmp(original_event.packet().data(), logged_event.rtcp.raw_data.data(),
1065 original_event.packet().size()),
1066 0);
1067 }
1068
VerifyLoggedRtcpPacketOutgoing(const RtcEventRtcpPacketOutgoing & original_event,const LoggedRtcpPacketOutgoing & logged_event) const1069 void EventVerifier::VerifyLoggedRtcpPacketOutgoing(
1070 const RtcEventRtcpPacketOutgoing& original_event,
1071 const LoggedRtcpPacketOutgoing& logged_event) const {
1072 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
1073
1074 ASSERT_EQ(original_event.packet().size(), logged_event.rtcp.raw_data.size());
1075 EXPECT_EQ(
1076 memcmp(original_event.packet().data(), logged_event.rtcp.raw_data.data(),
1077 original_event.packet().size()),
1078 0);
1079 }
1080
VerifyReportBlock(const rtcp::ReportBlock & original_report_block,const rtcp::ReportBlock & logged_report_block)1081 void EventVerifier::VerifyReportBlock(
1082 const rtcp::ReportBlock& original_report_block,
1083 const rtcp::ReportBlock& logged_report_block) {
1084 EXPECT_EQ(original_report_block.source_ssrc(),
1085 logged_report_block.source_ssrc());
1086 EXPECT_EQ(original_report_block.fraction_lost(),
1087 logged_report_block.fraction_lost());
1088 EXPECT_EQ(original_report_block.cumulative_lost_signed(),
1089 logged_report_block.cumulative_lost_signed());
1090 EXPECT_EQ(original_report_block.extended_high_seq_num(),
1091 logged_report_block.extended_high_seq_num());
1092 EXPECT_EQ(original_report_block.jitter(), logged_report_block.jitter());
1093 EXPECT_EQ(original_report_block.last_sr(), logged_report_block.last_sr());
1094 EXPECT_EQ(original_report_block.delay_since_last_sr(),
1095 logged_report_block.delay_since_last_sr());
1096 }
1097
VerifyLoggedSenderReport(int64_t log_time_us,const rtcp::SenderReport & original_sr,const LoggedRtcpPacketSenderReport & logged_sr)1098 void EventVerifier::VerifyLoggedSenderReport(
1099 int64_t log_time_us,
1100 const rtcp::SenderReport& original_sr,
1101 const LoggedRtcpPacketSenderReport& logged_sr) {
1102 EXPECT_EQ(log_time_us, logged_sr.log_time_us());
1103 EXPECT_EQ(original_sr.sender_ssrc(), logged_sr.sr.sender_ssrc());
1104 EXPECT_EQ(original_sr.ntp(), logged_sr.sr.ntp());
1105 EXPECT_EQ(original_sr.rtp_timestamp(), logged_sr.sr.rtp_timestamp());
1106 EXPECT_EQ(original_sr.sender_packet_count(),
1107 logged_sr.sr.sender_packet_count());
1108 EXPECT_EQ(original_sr.sender_octet_count(),
1109 logged_sr.sr.sender_octet_count());
1110 ASSERT_EQ(original_sr.report_blocks().size(),
1111 logged_sr.sr.report_blocks().size());
1112 for (size_t i = 0; i < original_sr.report_blocks().size(); i++) {
1113 VerifyReportBlock(original_sr.report_blocks()[i],
1114 logged_sr.sr.report_blocks()[i]);
1115 }
1116 }
1117
VerifyLoggedReceiverReport(int64_t log_time_us,const rtcp::ReceiverReport & original_rr,const LoggedRtcpPacketReceiverReport & logged_rr)1118 void EventVerifier::VerifyLoggedReceiverReport(
1119 int64_t log_time_us,
1120 const rtcp::ReceiverReport& original_rr,
1121 const LoggedRtcpPacketReceiverReport& logged_rr) {
1122 EXPECT_EQ(log_time_us, logged_rr.log_time_us());
1123 EXPECT_EQ(original_rr.sender_ssrc(), logged_rr.rr.sender_ssrc());
1124 ASSERT_EQ(original_rr.report_blocks().size(),
1125 logged_rr.rr.report_blocks().size());
1126 for (size_t i = 0; i < original_rr.report_blocks().size(); i++) {
1127 VerifyReportBlock(original_rr.report_blocks()[i],
1128 logged_rr.rr.report_blocks()[i]);
1129 }
1130 }
1131
VerifyLoggedExtendedReports(int64_t log_time_us,const rtcp::ExtendedReports & original_xr,const LoggedRtcpPacketExtendedReports & logged_xr)1132 void EventVerifier::VerifyLoggedExtendedReports(
1133 int64_t log_time_us,
1134 const rtcp::ExtendedReports& original_xr,
1135 const LoggedRtcpPacketExtendedReports& logged_xr) {
1136 EXPECT_EQ(original_xr.sender_ssrc(), logged_xr.xr.sender_ssrc());
1137
1138 EXPECT_EQ(original_xr.rrtr().has_value(), logged_xr.xr.rrtr().has_value());
1139 if (original_xr.rrtr().has_value() && logged_xr.xr.rrtr().has_value()) {
1140 EXPECT_EQ(original_xr.rrtr()->ntp(), logged_xr.xr.rrtr()->ntp());
1141 }
1142
1143 const auto& original_subblocks = original_xr.dlrr().sub_blocks();
1144 const auto& logged_subblocks = logged_xr.xr.dlrr().sub_blocks();
1145 ASSERT_EQ(original_subblocks.size(), logged_subblocks.size());
1146 for (size_t i = 0; i < original_subblocks.size(); i++) {
1147 EXPECT_EQ(original_subblocks[i].ssrc, logged_subblocks[i].ssrc);
1148 EXPECT_EQ(original_subblocks[i].last_rr, logged_subblocks[i].last_rr);
1149 EXPECT_EQ(original_subblocks[i].delay_since_last_rr,
1150 logged_subblocks[i].delay_since_last_rr);
1151 }
1152
1153 EXPECT_EQ(original_xr.target_bitrate().has_value(),
1154 logged_xr.xr.target_bitrate().has_value());
1155 if (original_xr.target_bitrate().has_value() &&
1156 logged_xr.xr.target_bitrate().has_value()) {
1157 const auto& original_bitrates =
1158 original_xr.target_bitrate()->GetTargetBitrates();
1159 const auto& logged_bitrates =
1160 logged_xr.xr.target_bitrate()->GetTargetBitrates();
1161 ASSERT_EQ(original_bitrates.size(), logged_bitrates.size());
1162 for (size_t i = 0; i < original_bitrates.size(); i++) {
1163 EXPECT_EQ(original_bitrates[i].spatial_layer,
1164 logged_bitrates[i].spatial_layer);
1165 EXPECT_EQ(original_bitrates[i].temporal_layer,
1166 logged_bitrates[i].temporal_layer);
1167 EXPECT_EQ(original_bitrates[i].target_bitrate_kbps,
1168 logged_bitrates[i].target_bitrate_kbps);
1169 }
1170 }
1171 }
1172
VerifyLoggedFir(int64_t log_time_us,const rtcp::Fir & original_fir,const LoggedRtcpPacketFir & logged_fir)1173 void EventVerifier::VerifyLoggedFir(int64_t log_time_us,
1174 const rtcp::Fir& original_fir,
1175 const LoggedRtcpPacketFir& logged_fir) {
1176 EXPECT_EQ(original_fir.sender_ssrc(), logged_fir.fir.sender_ssrc());
1177
1178 const auto& original_requests = original_fir.requests();
1179 const auto& logged_requests = logged_fir.fir.requests();
1180 ASSERT_EQ(original_requests.size(), logged_requests.size());
1181 for (size_t i = 0; i < original_requests.size(); i++) {
1182 EXPECT_EQ(original_requests[i].ssrc, logged_requests[i].ssrc);
1183 EXPECT_EQ(original_requests[i].seq_nr, logged_requests[i].seq_nr);
1184 }
1185 }
1186
VerifyLoggedPli(int64_t log_time_us,const rtcp::Pli & original_pli,const LoggedRtcpPacketPli & logged_pli)1187 void EventVerifier::VerifyLoggedPli(int64_t log_time_us,
1188 const rtcp::Pli& original_pli,
1189 const LoggedRtcpPacketPli& logged_pli) {
1190 EXPECT_EQ(original_pli.sender_ssrc(), logged_pli.pli.sender_ssrc());
1191 EXPECT_EQ(original_pli.media_ssrc(), logged_pli.pli.media_ssrc());
1192 }
1193
VerifyLoggedNack(int64_t log_time_us,const rtcp::Nack & original_nack,const LoggedRtcpPacketNack & logged_nack)1194 void EventVerifier::VerifyLoggedNack(int64_t log_time_us,
1195 const rtcp::Nack& original_nack,
1196 const LoggedRtcpPacketNack& logged_nack) {
1197 EXPECT_EQ(log_time_us, logged_nack.log_time_us());
1198 EXPECT_EQ(original_nack.packet_ids(), logged_nack.nack.packet_ids());
1199 }
1200
VerifyLoggedTransportFeedback(int64_t log_time_us,const rtcp::TransportFeedback & original_transport_feedback,const LoggedRtcpPacketTransportFeedback & logged_transport_feedback)1201 void EventVerifier::VerifyLoggedTransportFeedback(
1202 int64_t log_time_us,
1203 const rtcp::TransportFeedback& original_transport_feedback,
1204 const LoggedRtcpPacketTransportFeedback& logged_transport_feedback) {
1205 EXPECT_EQ(log_time_us, logged_transport_feedback.log_time_us());
1206 ASSERT_EQ(
1207 original_transport_feedback.GetReceivedPackets().size(),
1208 logged_transport_feedback.transport_feedback.GetReceivedPackets().size());
1209 for (size_t i = 0;
1210 i < original_transport_feedback.GetReceivedPackets().size(); i++) {
1211 EXPECT_EQ(
1212 original_transport_feedback.GetReceivedPackets()[i].sequence_number(),
1213 logged_transport_feedback.transport_feedback.GetReceivedPackets()[i]
1214 .sequence_number());
1215 EXPECT_EQ(
1216 original_transport_feedback.GetReceivedPackets()[i].delta_us(),
1217 logged_transport_feedback.transport_feedback.GetReceivedPackets()[i]
1218 .delta_us());
1219 }
1220 }
1221
VerifyLoggedRemb(int64_t log_time_us,const rtcp::Remb & original_remb,const LoggedRtcpPacketRemb & logged_remb)1222 void EventVerifier::VerifyLoggedRemb(int64_t log_time_us,
1223 const rtcp::Remb& original_remb,
1224 const LoggedRtcpPacketRemb& logged_remb) {
1225 EXPECT_EQ(log_time_us, logged_remb.log_time_us());
1226 EXPECT_EQ(original_remb.ssrcs(), logged_remb.remb.ssrcs());
1227 EXPECT_EQ(original_remb.bitrate_bps(), logged_remb.remb.bitrate_bps());
1228 }
1229
VerifyLoggedLossNotification(int64_t log_time_us,const rtcp::LossNotification & original_loss_notification,const LoggedRtcpPacketLossNotification & logged_loss_notification)1230 void EventVerifier::VerifyLoggedLossNotification(
1231 int64_t log_time_us,
1232 const rtcp::LossNotification& original_loss_notification,
1233 const LoggedRtcpPacketLossNotification& logged_loss_notification) {
1234 EXPECT_EQ(log_time_us, logged_loss_notification.log_time_us());
1235 EXPECT_EQ(original_loss_notification.last_decoded(),
1236 logged_loss_notification.loss_notification.last_decoded());
1237 EXPECT_EQ(original_loss_notification.last_received(),
1238 logged_loss_notification.loss_notification.last_received());
1239 EXPECT_EQ(original_loss_notification.decodability_flag(),
1240 logged_loss_notification.loss_notification.decodability_flag());
1241 }
1242
VerifyLoggedStartEvent(int64_t start_time_us,int64_t utc_start_time_us,const LoggedStartEvent & logged_event) const1243 void EventVerifier::VerifyLoggedStartEvent(
1244 int64_t start_time_us,
1245 int64_t utc_start_time_us,
1246 const LoggedStartEvent& logged_event) const {
1247 EXPECT_EQ(start_time_us / 1000, logged_event.log_time_ms());
1248 if (encoding_type_ == RtcEventLog::EncodingType::NewFormat) {
1249 EXPECT_EQ(utc_start_time_us / 1000, logged_event.utc_start_time_ms);
1250 }
1251 }
1252
VerifyLoggedStopEvent(int64_t stop_time_us,const LoggedStopEvent & logged_event) const1253 void EventVerifier::VerifyLoggedStopEvent(
1254 int64_t stop_time_us,
1255 const LoggedStopEvent& logged_event) const {
1256 EXPECT_EQ(stop_time_us / 1000, logged_event.log_time_ms());
1257 }
1258
VerifyLoggedStreamConfig(const rtclog::StreamConfig & original_config,const rtclog::StreamConfig & logged_config)1259 void VerifyLoggedStreamConfig(const rtclog::StreamConfig& original_config,
1260 const rtclog::StreamConfig& logged_config) {
1261 EXPECT_EQ(original_config.local_ssrc, logged_config.local_ssrc);
1262 EXPECT_EQ(original_config.remote_ssrc, logged_config.remote_ssrc);
1263 EXPECT_EQ(original_config.rtx_ssrc, logged_config.rtx_ssrc);
1264
1265 EXPECT_EQ(original_config.rtp_extensions.size(),
1266 logged_config.rtp_extensions.size());
1267 size_t recognized_extensions = 0;
1268 for (size_t i = 0; i < kMaxNumExtensions; i++) {
1269 auto original_id =
1270 GetExtensionId(original_config.rtp_extensions, kExtensions[i].name);
1271 auto logged_id =
1272 GetExtensionId(logged_config.rtp_extensions, kExtensions[i].name);
1273 EXPECT_EQ(original_id, logged_id)
1274 << "IDs for " << kExtensions[i].name << " don't match. Original ID "
1275 << original_id.value_or(-1) << ". Parsed ID " << logged_id.value_or(-1)
1276 << ".";
1277 if (original_id) {
1278 recognized_extensions++;
1279 }
1280 }
1281 EXPECT_EQ(recognized_extensions, original_config.rtp_extensions.size());
1282 }
1283
VerifyLoggedAudioRecvConfig(const RtcEventAudioReceiveStreamConfig & original_event,const LoggedAudioRecvConfig & logged_event) const1284 void EventVerifier::VerifyLoggedAudioRecvConfig(
1285 const RtcEventAudioReceiveStreamConfig& original_event,
1286 const LoggedAudioRecvConfig& logged_event) const {
1287 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
1288 VerifyLoggedStreamConfig(original_event.config(), logged_event.config);
1289 }
1290
VerifyLoggedAudioSendConfig(const RtcEventAudioSendStreamConfig & original_event,const LoggedAudioSendConfig & logged_event) const1291 void EventVerifier::VerifyLoggedAudioSendConfig(
1292 const RtcEventAudioSendStreamConfig& original_event,
1293 const LoggedAudioSendConfig& logged_event) const {
1294 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
1295 VerifyLoggedStreamConfig(original_event.config(), logged_event.config);
1296 }
1297
VerifyLoggedVideoRecvConfig(const RtcEventVideoReceiveStreamConfig & original_event,const LoggedVideoRecvConfig & logged_event) const1298 void EventVerifier::VerifyLoggedVideoRecvConfig(
1299 const RtcEventVideoReceiveStreamConfig& original_event,
1300 const LoggedVideoRecvConfig& logged_event) const {
1301 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
1302 VerifyLoggedStreamConfig(original_event.config(), logged_event.config);
1303 }
1304
VerifyLoggedVideoSendConfig(const RtcEventVideoSendStreamConfig & original_event,const LoggedVideoSendConfig & logged_event) const1305 void EventVerifier::VerifyLoggedVideoSendConfig(
1306 const RtcEventVideoSendStreamConfig& original_event,
1307 const LoggedVideoSendConfig& logged_event) const {
1308 EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms());
1309 VerifyLoggedStreamConfig(original_event.config(), logged_event.config);
1310 }
1311
1312 } // namespace test
1313 } // namespace webrtc
1314