Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(47)

Unified Diff: webrtc/logging/rtc_event_log/rtc_event_log_unittest.cc

Issue 3012273002: Ignore this CL - here as a baseline only (originally Bjorn's CL)
Patch Set: Created 3 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: webrtc/logging/rtc_event_log/rtc_event_log_unittest.cc
diff --git a/webrtc/logging/rtc_event_log/rtc_event_log_unittest.cc b/webrtc/logging/rtc_event_log/rtc_event_log_unittest.cc
index 1f592f23f2b69dceedb633f086627b4aa707a670..a297c6c2439b0c3b4aa4f2410f31ac56bd456fa8 100644
--- a/webrtc/logging/rtc_event_log/rtc_event_log_unittest.cc
+++ b/webrtc/logging/rtc_event_log/rtc_event_log_unittest.cc
@@ -25,10 +25,12 @@
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.h"
#include "webrtc/rtc_base/buffer.h"
#include "webrtc/rtc_base/checks.h"
#include "webrtc/rtc_base/fakeclock.h"
+#include "webrtc/rtc_base/ptr_util.h"
#include "webrtc/rtc_base/random.h"
#include "webrtc/test/gtest.h"
#include "webrtc/test/testsupport/fileutils.h"
@@ -44,72 +46,42 @@ namespace webrtc {
namespace {
+const uint8_t kTransmissionTimeOffsetExtensionId = 1;
+const uint8_t kAbsoluteSendTimeExtensionId = 14;
+const uint8_t kTransportSequenceNumberExtensionId = 13;
+const uint8_t kAudioLevelExtensionId = 9;
+const uint8_t kVideoRotationExtensionId = 5;
+
+const uint8_t kExtensionIds[] = {
+ kTransmissionTimeOffsetExtensionId, kAbsoluteSendTimeExtensionId,
+ kTransportSequenceNumberExtensionId, kAudioLevelExtensionId,
+ kVideoRotationExtensionId};
const RTPExtensionType kExtensionTypes[] = {
RTPExtensionType::kRtpExtensionTransmissionTimeOffset,
- RTPExtensionType::kRtpExtensionAudioLevel,
RTPExtensionType::kRtpExtensionAbsoluteSendTime,
- RTPExtensionType::kRtpExtensionVideoRotation,
- RTPExtensionType::kRtpExtensionTransportSequenceNumber};
+ RTPExtensionType::kRtpExtensionTransportSequenceNumber,
+ RTPExtensionType::kRtpExtensionAudioLevel,
+ RTPExtensionType::kRtpExtensionVideoRotation};
const char* kExtensionNames[] = {
- RtpExtension::kTimestampOffsetUri, RtpExtension::kAudioLevelUri,
- RtpExtension::kAbsSendTimeUri, RtpExtension::kVideoRotationUri,
- RtpExtension::kTransportSequenceNumberUri};
+ RtpExtension::kTimestampOffsetUri, RtpExtension::kAbsSendTimeUri,
+ RtpExtension::kTransportSequenceNumberUri, RtpExtension::kAudioLevelUri,
+ RtpExtension::kVideoRotationUri};
+
const size_t kNumExtensions = 5;
-void PrintActualEvents(const ParsedRtcEventLog& parsed_log) {
- std::map<int, size_t> actual_event_counts;
- for (size_t i = 0; i < parsed_log.GetNumberOfEvents(); i++) {
- actual_event_counts[parsed_log.GetEventType(i)]++;
- }
- printf("Actual events: ");
- for (auto kv : actual_event_counts) {
- printf("%d_count = %zu, ", kv.first, kv.second);
- }
- printf("\n");
- for (size_t i = 0; i < parsed_log.GetNumberOfEvents(); i++) {
- printf("%4d ", parsed_log.GetEventType(i));
- }
- printf("\n");
-}
+struct BweLossEvent {
+ int32_t bitrate_bps;
+ uint8_t fraction_loss;
+ int32_t total_packets;
+};
-void PrintExpectedEvents(size_t rtp_count,
- size_t rtcp_count,
- size_t playout_count,
- size_t bwe_loss_count) {
- printf(
- "Expected events: rtp_count = %zu, rtcp_count = %zu,"
- "playout_count = %zu, bwe_loss_count = %zu\n",
- rtp_count, rtcp_count, playout_count, bwe_loss_count);
- size_t rtcp_index = 1, playout_index = 1, bwe_loss_index = 1;
- printf("strt cfg cfg ");
- for (size_t i = 1; i <= rtp_count; i++) {
- printf(" rtp ");
- if (i * rtcp_count >= rtcp_index * rtp_count) {
- printf("rtcp ");
- rtcp_index++;
- }
- if (i * playout_count >= playout_index * rtp_count) {
- printf("play ");
- playout_index++;
- }
- if (i * bwe_loss_count >= bwe_loss_index * rtp_count) {
- printf("loss ");
- bwe_loss_index++;
- }
- }
- printf("end \n");
-}
} // namespace
-/*
- * Bit number i of extension_bitvector is set to indicate the
- * presence of extension number i from kExtensionTypes / kExtensionNames.
- * The least significant bit extension_bitvector has number 0.
- */
-RtpPacketToSend GenerateRtpPacket(const RtpHeaderExtensionMap* extensions,
- uint32_t csrcs_count,
- size_t packet_size,
- Random* prng) {
+RtpPacketToSend GenerateOutgoingRtpPacket(
+ const RtpHeaderExtensionMap* extensions,
+ uint32_t csrcs_count,
+ size_t packet_size,
+ Random* prng) {
RTC_CHECK_GE(packet_size, 16 + 4 * csrcs_count + 4 * kNumExtensions);
std::vector<uint32_t> csrcs;
@@ -139,6 +111,18 @@ RtpPacketToSend GenerateRtpPacket(const RtpHeaderExtensionMap* extensions,
return rtp_packet;
}
+RtpPacketReceived GenerateIncomingRtpPacket(
+ const RtpHeaderExtensionMap* extensions,
+ uint32_t csrcs_count,
+ size_t packet_size,
+ Random* prng) {
+ RtpPacketToSend packet_out =
+ GenerateOutgoingRtpPacket(extensions, csrcs_count, packet_size, prng);
+ RtpPacketReceived packet_in(extensions);
+ packet_in.Parse(packet_out.data(), packet_out.size());
+ return packet_in;
+}
+
rtc::Buffer GenerateRtcpPacket(Random* prng) {
rtcp::ReportBlock report_block;
report_block.SetMediaSsrc(prng->Rand<uint32_t>()); // Remote SSRC.
@@ -153,7 +137,7 @@ rtc::Buffer GenerateRtcpPacket(Random* prng) {
return sender_report.Build();
}
-void GenerateVideoReceiveConfig(uint32_t extensions_bitvector,
+void GenerateVideoReceiveConfig(const RtpHeaderExtensionMap& extensions,
rtclog::StreamConfig* config,
Random* prng) {
// Add SSRCs for the stream.
@@ -168,14 +152,14 @@ void GenerateVideoReceiveConfig(uint32_t extensions_bitvector,
prng->Rand(1, 127), prng->Rand(1, 127));
// Add header extensions.
for (unsigned i = 0; i < kNumExtensions; i++) {
- if (extensions_bitvector & (1u << i)) {
- config->rtp_extensions.emplace_back(kExtensionNames[i],
- prng->Rand<int>());
+ uint8_t id = extensions.GetId(kExtensionTypes[i]);
+ if (id != RtpHeaderExtensionMap::kInvalidId) {
+ config->rtp_extensions.emplace_back(kExtensionNames[i], id);
}
}
}
-void GenerateVideoSendConfig(uint32_t extensions_bitvector,
+void GenerateVideoSendConfig(const RtpHeaderExtensionMap& extensions,
rtclog::StreamConfig* config,
Random* prng) {
config->codecs.emplace_back(prng->Rand<bool>() ? "VP8" : "H264",
@@ -184,14 +168,14 @@ void GenerateVideoSendConfig(uint32_t extensions_bitvector,
config->rtx_ssrc = prng->Rand<uint32_t>();
// Add header extensions.
for (unsigned i = 0; i < kNumExtensions; i++) {
- if (extensions_bitvector & (1u << i)) {
- config->rtp_extensions.push_back(
- RtpExtension(kExtensionNames[i], prng->Rand<int>()));
+ uint8_t id = extensions.GetId(kExtensionTypes[i]);
+ if (id != RtpHeaderExtensionMap::kInvalidId) {
+ config->rtp_extensions.emplace_back(kExtensionNames[i], id);
}
}
}
-void GenerateAudioReceiveConfig(uint32_t extensions_bitvector,
+void GenerateAudioReceiveConfig(const RtpHeaderExtensionMap& extensions,
rtclog::StreamConfig* config,
Random* prng) {
// Add SSRCs for the stream.
@@ -199,28 +183,36 @@ void GenerateAudioReceiveConfig(uint32_t extensions_bitvector,
config->local_ssrc = prng->Rand<uint32_t>();
// Add header extensions.
for (unsigned i = 0; i < kNumExtensions; i++) {
- if (extensions_bitvector & (1u << i)) {
- config->rtp_extensions.push_back(
- RtpExtension(kExtensionNames[i], prng->Rand<int>()));
+ uint8_t id = extensions.GetId(kExtensionTypes[i]);
+ if (id != RtpHeaderExtensionMap::kInvalidId) {
+ config->rtp_extensions.emplace_back(kExtensionNames[i], id);
}
}
}
-void GenerateAudioSendConfig(uint32_t extensions_bitvector,
+void GenerateAudioSendConfig(const RtpHeaderExtensionMap& extensions,
rtclog::StreamConfig* config,
Random* prng) {
// Add SSRC to the stream.
config->local_ssrc = prng->Rand<uint32_t>();
// Add header extensions.
for (unsigned i = 0; i < kNumExtensions; i++) {
- if (extensions_bitvector & (1u << i)) {
- config->rtp_extensions.push_back(
- RtpExtension(kExtensionNames[i], prng->Rand<int>()));
+ uint8_t id = extensions.GetId(kExtensionTypes[i]);
+ if (id != RtpHeaderExtensionMap::kInvalidId) {
+ config->rtp_extensions.emplace_back(kExtensionNames[i], id);
}
}
}
-void GenerateAudioNetworkAdaptation(uint32_t extensions_bitvector,
+BweLossEvent GenerateBweLossEvent(Random* prng) {
+ BweLossEvent loss_event;
+ loss_event.bitrate_bps = prng->Rand(6000, 10000000);
+ loss_event.fraction_loss = prng->Rand<uint8_t>();
+ loss_event.total_packets = prng->Rand(1, 1000);
+ return loss_event;
+}
+
+void GenerateAudioNetworkAdaptation(const RtpHeaderExtensionMap& extensions,
AudioEncoderRuntimeConfig* config,
Random* prng) {
config->bitrate_bps = rtc::Optional<int>(prng->Rand(0, 3000000));
@@ -232,201 +224,498 @@ void GenerateAudioNetworkAdaptation(uint32_t extensions_bitvector,
rtc::Optional<float>(prng->Rand<float>());
}
-// Test for the RtcEventLog class. Dumps some RTP packets and other events
-// to disk, then reads them back to see if they match.
-void LogSessionAndReadBack(size_t rtp_count,
- size_t rtcp_count,
- size_t playout_count,
- size_t bwe_loss_count,
- uint32_t extensions_bitvector,
- uint32_t csrcs_count,
- unsigned int random_seed) {
- ASSERT_LE(rtcp_count, rtp_count);
- ASSERT_LE(playout_count, rtp_count);
- ASSERT_LE(bwe_loss_count, rtp_count);
- std::vector<RtpPacketToSend> rtp_packets;
- std::vector<rtc::Buffer> rtcp_packets;
- std::vector<uint32_t> playout_ssrcs;
- std::vector<std::pair<int32_t, uint8_t> > bwe_loss_updates;
-
- rtclog::StreamConfig receiver_config;
- rtclog::StreamConfig sender_config;
+// TODO(terelius): Merge with event type in parser once updated?
+enum class EventType {
+ INCOMING_RTP = 1,
+ OUTGOING_RTP = 2,
+ INCOMING_RTCP = 3,
+ OUTGOING_RTCP = 4,
+ AUDIO_PLAYOUT = 5,
+ BWE_LOSS_UPDATE = 6,
+ BWE_DELAY_UPDATE = 7,
+ VIDEO_RECV_CONFIG = 8,
+ VIDEO_SEND_CONFIG = 9,
+ AUDIO_RECV_CONFIG = 10,
+ AUDIO_SEND_CONFIG = 11,
+ AUDIO_NETWORK_ADAPTATION = 12,
+ BWE_PROBE_CLUSTER_CREATED = 13,
+ BWE_PROBE_RESULT = 14,
+};
- Random prng(random_seed);
+class SessionDescription {
+ public:
+ explicit SessionDescription(unsigned int random_seed) : prng(random_seed) {}
+ void GenerateSessionDescription(size_t incoming_rtp_count,
+ size_t outgoing_rtp_count,
+ size_t incoming_rtcp_count,
+ size_t outgoing_rtcp_count,
+ size_t playout_count,
+ size_t bwe_loss_count,
+ size_t bwe_delay_count,
+ const RtpHeaderExtensionMap& extensions,
+ uint32_t csrcs_count);
+ void WriteSession();
+ void ReadAndVerifySession();
+ void PrintExpectedEvents();
+
+ private:
+ std::vector<RtpPacketReceived> incoming_rtp_packets;
+ std::vector<RtpPacketToSend> outgoing_rtp_packets;
+ std::vector<rtc::Buffer> incoming_rtcp_packets;
+ std::vector<rtc::Buffer> outgoing_rtcp_packets;
+ std::vector<uint32_t> playout_ssrcs;
+ std::vector<BweLossEvent> bwe_loss_updates;
+ std::vector<std::pair<int32_t, BandwidthUsage> > bwe_delay_updates;
+ std::vector<rtclog::StreamConfig> receiver_configs;
+ std::vector<rtclog::StreamConfig> sender_configs;
+ std::vector<EventType> event_types;
+ Random prng;
+};
- // Initialize rtp header extensions to be used in generated rtp packets.
- RtpHeaderExtensionMap extensions;
- for (unsigned i = 0; i < kNumExtensions; i++) {
- if (extensions_bitvector & (1u << i)) {
- extensions.Register(kExtensionTypes[i], i + 1);
- }
+void SessionDescription::GenerateSessionDescription(
+ size_t incoming_rtp_count,
+ size_t outgoing_rtp_count,
+ size_t incoming_rtcp_count,
+ size_t outgoing_rtcp_count,
+ size_t playout_count,
+ size_t bwe_loss_count,
+ size_t bwe_delay_count,
+ const RtpHeaderExtensionMap& extensions,
+ uint32_t csrcs_count) {
+ // Create configuration for the video receive stream.
+ receiver_configs.emplace_back(rtclog::StreamConfig());
+ GenerateVideoReceiveConfig(extensions, &receiver_configs.back(), &prng);
+ event_types.push_back(EventType::VIDEO_RECV_CONFIG);
+
+ // Create configuration for the video send stream.
+ sender_configs.emplace_back(rtclog::StreamConfig());
+ GenerateVideoSendConfig(extensions, &sender_configs.back(), &prng);
+ event_types.push_back(EventType::VIDEO_SEND_CONFIG);
+ const size_t config_count = 2;
+
+ // Create incoming and outgoing RTP packets containing random data.
+ for (size_t i = 0; i < incoming_rtp_count; i++) {
+ size_t packet_size = prng.Rand(1000, 1100);
+ incoming_rtp_packets.push_back(GenerateIncomingRtpPacket(
+ &extensions, csrcs_count, packet_size, &prng));
+ event_types.push_back(EventType::INCOMING_RTP);
}
- // Create rtp_count RTP packets containing random data.
- for (size_t i = 0; i < rtp_count; i++) {
+ for (size_t i = 0; i < outgoing_rtp_count; i++) {
size_t packet_size = prng.Rand(1000, 1100);
- rtp_packets.push_back(
- GenerateRtpPacket(&extensions, csrcs_count, packet_size, &prng));
+ outgoing_rtp_packets.push_back(GenerateOutgoingRtpPacket(
+ &extensions, csrcs_count, packet_size, &prng));
+ event_types.push_back(EventType::OUTGOING_RTP);
}
- // Create rtcp_count RTCP packets containing random data.
- for (size_t i = 0; i < rtcp_count; i++) {
- rtcp_packets.push_back(GenerateRtcpPacket(&prng));
+ // Create incoming and outgoing RTCP packets containing random data.
+ for (size_t i = 0; i < incoming_rtcp_count; i++) {
+ incoming_rtcp_packets.push_back(GenerateRtcpPacket(&prng));
+ event_types.push_back(EventType::INCOMING_RTCP);
}
- // Create playout_count random SSRCs to use when logging AudioPlayout events.
+ for (size_t i = 0; i < outgoing_rtcp_count; i++) {
+ outgoing_rtcp_packets.push_back(GenerateRtcpPacket(&prng));
+ event_types.push_back(EventType::OUTGOING_RTCP);
+ }
+ // Create random SSRCs to use when logging AudioPlayout events.
for (size_t i = 0; i < playout_count; i++) {
playout_ssrcs.push_back(prng.Rand<uint32_t>());
+ event_types.push_back(EventType::AUDIO_PLAYOUT);
}
- // Create bwe_loss_count random bitrate updates for LossBasedBwe.
+ // Create random bitrate updates for LossBasedBwe.
for (size_t i = 0; i < bwe_loss_count; i++) {
- bwe_loss_updates.push_back(
- std::make_pair(prng.Rand<int32_t>(), prng.Rand<uint8_t>()));
+ bwe_loss_updates.push_back(GenerateBweLossEvent(&prng));
+ event_types.push_back(EventType::BWE_LOSS_UPDATE);
+ }
+ // Create random bitrate updates for DelayBasedBwe.
+ for (size_t i = 0; i < bwe_delay_count; i++) {
+ bwe_delay_updates.push_back(std::make_pair(
+ prng.Rand(6000, 10000000), prng.Rand<bool>()
+ ? BandwidthUsage::kBwOverusing
+ : BandwidthUsage::kBwUnderusing));
+ event_types.push_back(EventType::BWE_DELAY_UPDATE);
+ }
+
+ // Order the events randomly. The configurations are stored in a separate
+ // buffer, so they might be written before any othe events. Hence, we can't
+ // mix the config events with other events.
+ for (size_t i = config_count; i < event_types.size(); i++) {
+ size_t other = prng.Rand(static_cast<uint32_t>(i),
+ static_cast<uint32_t>(event_types.size() - 1));
+ std::swap(event_types[i], event_types[other]);
}
- // Create configurations for the video streams.
- GenerateVideoReceiveConfig(extensions_bitvector, &receiver_config, &prng);
- GenerateVideoSendConfig(extensions_bitvector, &sender_config, &prng);
- const int config_count = 2;
+}
+void SessionDescription::WriteSession() {
// Find the name of the current test, in order to use it as a temporary
// filename.
auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
const std::string temp_filename =
test::OutputPath() + test_info->test_case_name() + test_info->name();
+ rtc::ScopedFakeClock fake_clock;
+ fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
+
// When log_dumper goes out of scope, it causes the log file to be flushed
// to disk.
- {
- rtc::ScopedFakeClock fake_clock;
- fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
- std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
- log_dumper->LogVideoReceiveStreamConfig(receiver_config);
- fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
- log_dumper->LogVideoSendStreamConfig(sender_config);
+ std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
+
+ size_t incoming_rtp_written = 0;
+ size_t outgoing_rtp_written = 0;
+ size_t incoming_rtcp_written = 0;
+ size_t outgoing_rtcp_written = 0;
+ size_t playouts_written = 0;
+ size_t bwe_loss_written = 0;
+ size_t bwe_delay_written = 0;
+ size_t recv_configs_written = 0;
+ size_t send_configs_written = 0;
+
+ for (size_t i = 0; i < event_types.size(); i++) {
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
- size_t rtcp_index = 1;
- size_t playout_index = 1;
- size_t bwe_loss_index = 1;
- for (size_t i = 1; i <= rtp_count; i++) {
- log_dumper->LogRtpHeader(
- (i % 2 == 0) ? kIncomingPacket : kOutgoingPacket,
- rtp_packets[i - 1].data(), rtp_packets[i - 1].size());
- fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
- if (i * rtcp_count >= rtcp_index * rtp_count) {
- log_dumper->LogRtcpPacket(
- (rtcp_index % 2 == 0) ? kIncomingPacket : kOutgoingPacket,
- rtcp_packets[rtcp_index - 1].data(),
- rtcp_packets[rtcp_index - 1].size());
- rtcp_index++;
- fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
- }
- if (i * playout_count >= playout_index * rtp_count) {
- log_dumper->LogAudioPlayout(playout_ssrcs[playout_index - 1]);
- playout_index++;
- fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
- }
- if (i * bwe_loss_count >= bwe_loss_index * rtp_count) {
+ if (i == event_types.size() / 2)
+ log_dumper->StartLogging(temp_filename, 10000000);
+ switch (event_types[i]) {
+ case EventType::INCOMING_RTP:
+ log_dumper->LogIncomingRtpHeader(
+ incoming_rtp_packets[incoming_rtp_written++]);
+ break;
+ case EventType::OUTGOING_RTP:
+ log_dumper->LogOutgoingRtpHeader(
+ outgoing_rtp_packets[outgoing_rtp_written++],
+ PacedPacketInfo::kNotAProbe);
+ break;
+ case EventType::INCOMING_RTCP:
+ log_dumper->LogIncomingRtcpPacket(
+ incoming_rtcp_packets[incoming_rtcp_written++]);
+ break;
+ case EventType::OUTGOING_RTCP:
+ log_dumper->LogOutgoingRtcpPacket(
+ outgoing_rtcp_packets[outgoing_rtcp_written++]);
+ break;
+ case EventType::AUDIO_PLAYOUT:
+ log_dumper->LogAudioPlayout(playout_ssrcs[playouts_written++]);
+ break;
+ case EventType::BWE_LOSS_UPDATE:
log_dumper->LogLossBasedBweUpdate(
- bwe_loss_updates[bwe_loss_index - 1].first,
- bwe_loss_updates[bwe_loss_index - 1].second, i);
- bwe_loss_index++;
- fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
- }
- if (i == rtp_count / 2) {
- log_dumper->StartLogging(temp_filename, 10000000);
- fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
- }
+ bwe_loss_updates[bwe_loss_written].bitrate_bps,
+ bwe_loss_updates[bwe_loss_written].fraction_loss,
+ bwe_loss_updates[bwe_loss_written].total_packets);
+ bwe_loss_written++;
+ break;
+ case EventType::BWE_DELAY_UPDATE:
+ log_dumper->LogDelayBasedBweUpdate(
+ bwe_delay_updates[bwe_delay_written].first,
+ bwe_delay_updates[bwe_delay_written].second);
+ bwe_delay_written++;
+ break;
+ case EventType::VIDEO_RECV_CONFIG:
+ log_dumper->LogVideoReceiveStreamConfig(
+ receiver_configs[recv_configs_written++]);
+ break;
+ case EventType::VIDEO_SEND_CONFIG:
+ log_dumper->LogVideoSendStreamConfig(
+ sender_configs[send_configs_written++]);
+ break;
+ case EventType::AUDIO_RECV_CONFIG:
+ // Not implemented
+ RTC_NOTREACHED();
+ break;
+ case EventType::AUDIO_SEND_CONFIG:
+ // Not implemented
+ RTC_NOTREACHED();
+ break;
+ case EventType::AUDIO_NETWORK_ADAPTATION:
+ // Not implemented
+ RTC_NOTREACHED();
+ break;
+ case EventType::BWE_PROBE_CLUSTER_CREATED:
+ // Not implemented
+ RTC_NOTREACHED();
+ break;
+ case EventType::BWE_PROBE_RESULT:
+ // Not implemented
+ RTC_NOTREACHED();
+ break;
}
- log_dumper->StopLogging();
}
+ log_dumper->StopLogging();
+}
+
+// Read the file and verify that what we read back from the event log is the
+// same as what we wrote down.
+void SessionDescription::ReadAndVerifySession() {
+ // Find the name of the current test, in order to use it as a temporary
+ // filename.
+ auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
+ const std::string temp_filename =
+ test::OutputPath() + test_info->test_case_name() + test_info->name();
+
// Read the generated file from disk.
ParsedRtcEventLog parsed_log;
-
ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
+ EXPECT_GE(1000u, event_types.size() +
+ 2); // The events must fit in the message queue.
+ EXPECT_EQ(event_types.size() + 2, parsed_log.GetNumberOfEvents());
+
+ size_t incoming_rtp_read = 0;
+ size_t outgoing_rtp_read = 0;
+ size_t incoming_rtcp_read = 0;
+ size_t outgoing_rtcp_read = 0;
+ size_t playouts_read = 0;
+ size_t bwe_loss_read = 0;
+ size_t bwe_delay_read = 0;
+ size_t recv_configs_read = 0;
+ size_t send_configs_read = 0;
- // Verify that what we read back from the event log is the same as
- // what we wrote down. For RTCP we log the full packets, but for
- // RTP we should only log the header.
- const size_t event_count = config_count + playout_count + bwe_loss_count +
- rtcp_count + rtp_count + 2;
- EXPECT_GE(1000u, event_count); // The events must fit in the message queue.
- EXPECT_EQ(event_count, parsed_log.GetNumberOfEvents());
- if (event_count != parsed_log.GetNumberOfEvents()) {
- // Print the expected and actual event types for easier debugging.
- PrintActualEvents(parsed_log);
- PrintExpectedEvents(rtp_count, rtcp_count, playout_count, bwe_loss_count);
- }
RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0);
- RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(parsed_log, 1,
- receiver_config);
- RtcEventLogTestHelper::VerifyVideoSendStreamConfig(parsed_log, 2,
- sender_config);
- size_t event_index = config_count + 1;
- size_t rtcp_index = 1;
- size_t playout_index = 1;
- size_t bwe_loss_index = 1;
- for (size_t i = 1; i <= rtp_count; i++) {
- RtcEventLogTestHelper::VerifyRtpEvent(
- parsed_log, event_index,
- (i % 2 == 0) ? kIncomingPacket : kOutgoingPacket,
- rtp_packets[i - 1].data(), rtp_packets[i - 1].headers_size(),
- rtp_packets[i - 1].size());
- event_index++;
- if (i * rtcp_count >= rtcp_index * rtp_count) {
- RtcEventLogTestHelper::VerifyRtcpEvent(
- parsed_log, event_index,
- rtcp_index % 2 == 0 ? kIncomingPacket : kOutgoingPacket,
- rtcp_packets[rtcp_index - 1].data(),
- rtcp_packets[rtcp_index - 1].size());
- event_index++;
- rtcp_index++;
- }
- if (i * playout_count >= playout_index * rtp_count) {
- RtcEventLogTestHelper::VerifyPlayoutEvent(
- parsed_log, event_index, playout_ssrcs[playout_index - 1]);
- event_index++;
- playout_index++;
- }
- if (i * bwe_loss_count >= bwe_loss_index * rtp_count) {
- RtcEventLogTestHelper::VerifyBweLossEvent(
- parsed_log, event_index, bwe_loss_updates[bwe_loss_index - 1].first,
- bwe_loss_updates[bwe_loss_index - 1].second, i);
- event_index++;
- bwe_loss_index++;
+
+ for (size_t i = 0; i < event_types.size(); i++) {
+ switch (event_types[i]) {
+ case EventType::INCOMING_RTP:
+ RtcEventLogTestHelper::VerifyRtpEvent(
+ parsed_log, i + 1, kIncomingPacket,
+ incoming_rtp_packets[incoming_rtp_read++]);
+ break;
+ case EventType::OUTGOING_RTP:
+ RtcEventLogTestHelper::VerifyRtpEvent(
+ parsed_log, i + 1, kOutgoingPacket,
+ outgoing_rtp_packets[outgoing_rtp_read++]);
+ break;
+ case EventType::INCOMING_RTCP:
+ RtcEventLogTestHelper::VerifyRtcpEvent(
+ parsed_log, i + 1, kIncomingPacket,
+ incoming_rtcp_packets[incoming_rtcp_read].data(),
+ incoming_rtcp_packets[incoming_rtcp_read].size());
+ incoming_rtcp_read++;
+ break;
+ case EventType::OUTGOING_RTCP:
+ RtcEventLogTestHelper::VerifyRtcpEvent(
+ parsed_log, i + 1, kOutgoingPacket,
+ outgoing_rtcp_packets[outgoing_rtcp_read].data(),
+ outgoing_rtcp_packets[outgoing_rtcp_read].size());
+ outgoing_rtcp_read++;
+ break;
+ case EventType::AUDIO_PLAYOUT:
+ RtcEventLogTestHelper::VerifyPlayoutEvent(
+ parsed_log, i + 1, playout_ssrcs[playouts_read++]);
+ break;
+ case EventType::BWE_LOSS_UPDATE:
+ RtcEventLogTestHelper::VerifyBweLossEvent(
+ parsed_log, i + 1, bwe_loss_updates[bwe_loss_read].bitrate_bps,
+ bwe_loss_updates[bwe_loss_read].fraction_loss,
+ bwe_loss_updates[bwe_loss_read].total_packets);
+ bwe_loss_read++;
+ break;
+ case EventType::BWE_DELAY_UPDATE:
+ RtcEventLogTestHelper::VerifyBweDelayEvent(
+ parsed_log, i + 1, bwe_delay_updates[bwe_delay_read].first,
+ bwe_delay_updates[bwe_delay_read].second);
+ bwe_delay_read++;
+ break;
+ case EventType::VIDEO_RECV_CONFIG:
+ RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(
+ parsed_log, i + 1, receiver_configs[recv_configs_read++]);
+ break;
+ case EventType::VIDEO_SEND_CONFIG:
+ RtcEventLogTestHelper::VerifyVideoSendStreamConfig(
+ parsed_log, i + 1, sender_configs[send_configs_read++]);
+ break;
+ case EventType::AUDIO_RECV_CONFIG:
+ // Not implemented
+ RTC_NOTREACHED();
+ break;
+ case EventType::AUDIO_SEND_CONFIG:
+ // Not implemented
+ RTC_NOTREACHED();
+ break;
+ case EventType::AUDIO_NETWORK_ADAPTATION:
+ // Not implemented
+ RTC_NOTREACHED();
+ break;
+ case EventType::BWE_PROBE_CLUSTER_CREATED:
+ // Not implemented
+ RTC_NOTREACHED();
+ break;
+ case EventType::BWE_PROBE_RESULT:
+ // Not implemented
+ RTC_NOTREACHED();
+ break;
}
}
+ RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log,
+ parsed_log.GetNumberOfEvents() - 1);
+
// Clean up temporary file - can be pretty slow.
remove(temp_filename.c_str());
}
-TEST(RtcEventLogTest, LogSessionAndReadBack) {
- // Log 5 RTP, 2 RTCP, 0 playout events and 0 BWE events
- // with no header extensions or CSRCS.
- LogSessionAndReadBack(5, 2, 0, 0, 0, 0, 321);
+void SessionDescription::PrintExpectedEvents() {
+ for (size_t i = 0; i < event_types.size(); i++) {
+ switch (event_types[i]) {
+ case EventType::INCOMING_RTP:
+ printf("RTP(in) ");
+ break;
+ case EventType::OUTGOING_RTP:
+ printf("RTP(out) ");
+ break;
+ case EventType::INCOMING_RTCP:
+ printf("RTCP(in) ");
+ break;
+ case EventType::OUTGOING_RTCP:
+ printf("RTCP(out) ");
+ break;
+ case EventType::AUDIO_PLAYOUT:
+ printf("PLAYOUT ");
+ break;
+ case EventType::BWE_LOSS_UPDATE:
+ printf("BWE_LOSS ");
+ break;
+ case EventType::BWE_DELAY_UPDATE:
+ printf("BWE_DELAY ");
+ break;
+ case EventType::VIDEO_RECV_CONFIG:
+ printf("VIDEO_RECV_CONFIG ");
+ break;
+ case EventType::VIDEO_SEND_CONFIG:
+ printf("VIDEO_SEND_CONFIG ");
+ break;
+ case EventType::AUDIO_RECV_CONFIG:
+ printf("AUDIO_RECV_CONFIG ");
+ break;
+ case EventType::AUDIO_SEND_CONFIG:
+ printf("AUDIO_SEND_CONFIG ");
+ break;
+ case EventType::AUDIO_NETWORK_ADAPTATION:
+ printf("ANA ");
+ break;
+ case EventType::BWE_PROBE_CLUSTER_CREATED:
+ printf("BWE_PROBE_CREATED ");
+ break;
+ case EventType::BWE_PROBE_RESULT:
+ printf("BWE_PROBE_RESULT ");
+ break;
+ }
+ }
+ printf("\n");
+}
- // Enable AbsSendTime and TransportSequenceNumbers.
- uint32_t extensions = 0;
- for (uint32_t i = 0; i < kNumExtensions; i++) {
- if (kExtensionTypes[i] == RTPExtensionType::kRtpExtensionAbsoluteSendTime ||
- kExtensionTypes[i] ==
- RTPExtensionType::kRtpExtensionTransportSequenceNumber) {
- extensions |= 1u << i;
+void PrintActualEvents(const ParsedRtcEventLog& parsed_log) {
+ for (size_t i = 0; i < parsed_log.GetNumberOfEvents(); i++) {
+ switch (parsed_log.GetEventType(i)) {
+ case ParsedRtcEventLog::EventType::UNKNOWN_EVENT:
+ printf("UNKNOWN_EVENT ");
+ break;
+ case ParsedRtcEventLog::EventType::LOG_START:
+ printf("LOG_START ");
+ break;
+ case ParsedRtcEventLog::EventType::LOG_END:
+ printf("LOG_END ");
+ break;
+ case ParsedRtcEventLog::EventType::RTP_EVENT:
+ printf("RTP_EVENT ");
+ break;
+ case ParsedRtcEventLog::EventType::RTCP_EVENT:
+ printf("RTCP_EVENT ");
+ break;
+ case ParsedRtcEventLog::EventType::AUDIO_PLAYOUT_EVENT:
+ printf("AUDIO_PLAYOUT_EVENT ");
+ break;
+ case ParsedRtcEventLog::EventType::LOSS_BASED_BWE_UPDATE:
+ printf("LOSS_BASED_BWE_UPDATE ");
+ break;
+ case ParsedRtcEventLog::EventType::DELAY_BASED_BWE_UPDATE:
+ printf("DELAY_BASED_BWE_UPDATE ");
+ break;
+ case ParsedRtcEventLog::EventType::VIDEO_RECEIVER_CONFIG_EVENT:
+ printf("VIDEO_RECEIVER_CONFIG_EVET ");
+ break;
+ case ParsedRtcEventLog::EventType::VIDEO_SENDER_CONFIG_EVENT:
+ printf("VIDEO_SENDER_CONFIG_EVENT ");
+ break;
+ case ParsedRtcEventLog::EventType::AUDIO_RECEIVER_CONFIG_EVENT:
+ printf("AUDIO_RECEIVER_CONFIG_EVET ");
+ break;
+ case ParsedRtcEventLog::EventType::AUDIO_SENDER_CONFIG_EVENT:
+ printf("AUDIO_SENDER_CONFIG_EVENT ");
+ break;
+ case ParsedRtcEventLog::EventType::AUDIO_NETWORK_ADAPTATION_EVENT:
+ printf("AUDIO_NETWORK_ADAPTATION_EVENT ");
+ break;
+ case ParsedRtcEventLog::EventType::BWE_PROBE_CLUSTER_CREATED_EVENT:
+ printf("BWE_PROBE_CLUSTER_CREATED_EVENT ");
+ break;
+ case ParsedRtcEventLog::EventType::BWE_PROBE_RESULT_EVENT:
+ printf("BWE_PROBE_RESULT_EVENT ");
+ break;
}
}
- LogSessionAndReadBack(8, 2, 0, 0, extensions, 0, 3141592653u);
+ printf("\n");
+}
- extensions = (1u << kNumExtensions) - 1; // Enable all header extensions.
- LogSessionAndReadBack(9, 2, 3, 2, extensions, 2, 2718281828u);
+TEST(RtcEventLogTest, LogSessionAndReadBack) {
+ RtpHeaderExtensionMap extensions;
+ SessionDescription session(321 /*Random seed*/);
+ session.GenerateSessionDescription(3, // Number of incoming RTP packets.
+ 2, // Number of outgoing RTP packets.
+ 1, // Number of incoming RTCP packets.
+ 1, // Number of outgoing RTCP packets.
+ 0, // Number of playout events.
+ 0, // Number of BWE loss events.
+ 0, // Number of BWE delay events.
+ extensions, // No extensions.
+ 0); // Number of contributing sources.
+ session.WriteSession();
+ session.ReadAndVerifySession();
+}
+TEST(RtcEventLogTest, LogSessionAndReadBackWith2Extensions) {
+ RtpHeaderExtensionMap extensions;
+ extensions.Register(kRtpExtensionAbsoluteSendTime,
+ kAbsoluteSendTimeExtensionId);
+ extensions.Register(kRtpExtensionTransportSequenceNumber,
+ kTransportSequenceNumberExtensionId);
+ SessionDescription session(3141592653u /*Random seed*/);
+ session.GenerateSessionDescription(4, 4, 1, 1, 0, 0, 0, extensions, 0);
+ session.WriteSession();
+ session.ReadAndVerifySession();
+}
+
+TEST(RtcEventLogTest, LogSessionAndReadBackWithAllExtensions) {
+ RtpHeaderExtensionMap extensions;
+ for (uint32_t i = 0; i < kNumExtensions; i++) {
+ extensions.Register(kExtensionTypes[i], kExtensionIds[i]);
+ }
+ SessionDescription session(2718281828u /*Random seed*/);
+ session.GenerateSessionDescription(5, 4, 1, 1, 3, 2, 2, extensions, 2);
+ session.WriteSession();
+ session.ReadAndVerifySession();
+}
+
+TEST(RtcEventLogTest, LogSessionAndReadBackAllCombinations) {
// Try all combinations of header extensions and up to 2 CSRCS.
- for (extensions = 0; extensions < (1u << kNumExtensions); extensions++) {
+ for (uint32_t extension_selection = 0;
+ extension_selection < (1u << kNumExtensions); extension_selection++) {
+ RtpHeaderExtensionMap extensions;
+ for (uint32_t i = 0; i < kNumExtensions; i++) {
+ if (extension_selection & (1u << i)) {
+ extensions.Register(kExtensionTypes[i], kExtensionIds[i]);
+ }
+ }
for (uint32_t csrcs_count = 0; csrcs_count < 3; csrcs_count++) {
- LogSessionAndReadBack(5 + extensions, // Number of RTP packets.
- 2 + csrcs_count, // Number of RTCP packets.
- 3 + csrcs_count, // Number of playout events.
- 1 + csrcs_count, // Number of BWE loss events.
- extensions, // Bit vector choosing extensions.
- csrcs_count, // Number of contributing sources.
- extensions * 3 + csrcs_count + 1); // Random seed.
+ SessionDescription session(extension_selection * 3 + csrcs_count +
+ 1 /*Random seed*/);
+ session.GenerateSessionDescription(
+ 2 + extension_selection, // Number of incoming RTP packets.
+ 2 + extension_selection, // Number of outgoing RTP packets.
+ 1 + csrcs_count, // Number of incoming RTCP packets.
+ 1 + csrcs_count, // Number of outgoing RTCP packets.
+ 3 + csrcs_count, // Number of playout events.
+ 1 + csrcs_count, // Number of BWE loss events.
+ 2 + csrcs_count, // Number of BWE delay events.
+ extensions, // Bit vector choosing extensions.
+ csrcs_count); // Number of contributing sources.
+ session.WriteSession();
+ session.ReadAndVerifySession();
}
}
}
@@ -436,8 +725,8 @@ TEST(RtcEventLogTest, LogEventAndReadBack) {
// Create one RTP and one RTCP packet containing random data.
size_t packet_size = prng.Rand(1000, 1100);
- RtpPacketToSend rtp_packet =
- GenerateRtpPacket(nullptr, 0, packet_size, &prng);
+ RtpPacketReceived rtp_packet =
+ GenerateIncomingRtpPacket(nullptr, 0, packet_size, &prng);
rtc::Buffer rtcp_packet = GenerateRtcpPacket(&prng);
// Find the name of the current test, in order to use it as a temporary
@@ -451,15 +740,13 @@ TEST(RtcEventLogTest, LogEventAndReadBack) {
fake_clock.SetTimeMicros(prng.Rand<uint32_t>());
std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
- log_dumper->LogRtpHeader(kIncomingPacket, rtp_packet.data(),
- rtp_packet.size());
+ log_dumper->LogIncomingRtpHeader(rtp_packet);
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
log_dumper->StartLogging(temp_filename, 10000000);
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
- log_dumper->LogRtcpPacket(kOutgoingPacket, rtcp_packet.data(),
- rtcp_packet.size());
+ log_dumper->LogOutgoingRtcpPacket(rtcp_packet);
fake_clock.AdvanceTimeMicros(prng.Rand(1, 1000));
log_dumper->StopLogging();
@@ -474,9 +761,8 @@ TEST(RtcEventLogTest, LogEventAndReadBack) {
RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0);
- RtcEventLogTestHelper::VerifyRtpEvent(
- parsed_log, 1, kIncomingPacket, rtp_packet.data(),
- rtp_packet.headers_size(), rtp_packet.size());
+ RtcEventLogTestHelper::VerifyRtpEvent(parsed_log, 1, kIncomingPacket,
+ rtp_packet);
RtcEventLogTestHelper::VerifyRtcpEvent(
parsed_log, 2, kOutgoingPacket, rtcp_packet.data(), rtcp_packet.size());
@@ -721,7 +1007,7 @@ class ConfigReadWriteTest {
public:
ConfigReadWriteTest() : prng(987654321) {}
virtual ~ConfigReadWriteTest() {}
- virtual void GenerateConfig(uint32_t extensions_bitvector) = 0;
+ virtual void GenerateConfig(const RtpHeaderExtensionMap& extensions) = 0;
virtual void VerifyConfig(const ParsedRtcEventLog& parsed_log,
size_t index) = 0;
virtual void LogConfig(RtcEventLog* event_log) = 0;
@@ -734,8 +1020,11 @@ class ConfigReadWriteTest {
test::OutputPath() + test_info->test_case_name() + test_info->name();
// Use all extensions.
- uint32_t extensions_bitvector = (1u << kNumExtensions) - 1;
- GenerateConfig(extensions_bitvector);
+ RtpHeaderExtensionMap extensions;
+ for (uint32_t i = 0; i < kNumExtensions; i++) {
+ extensions.Register(kExtensionTypes[i], kExtensionIds[i]);
+ }
+ GenerateConfig(extensions);
// Log a single config event and stop logging.
rtc::ScopedFakeClock fake_clock;
@@ -768,8 +1057,8 @@ class ConfigReadWriteTest {
class AudioReceiveConfigReadWriteTest : public ConfigReadWriteTest {
public:
- void GenerateConfig(uint32_t extensions_bitvector) override {
- GenerateAudioReceiveConfig(extensions_bitvector, &config, &prng);
+ void GenerateConfig(const RtpHeaderExtensionMap& extensions) override {
+ GenerateAudioReceiveConfig(extensions, &config, &prng);
}
void LogConfig(RtcEventLog* event_log) override {
event_log->LogAudioReceiveStreamConfig(config);
@@ -785,8 +1074,8 @@ class AudioReceiveConfigReadWriteTest : public ConfigReadWriteTest {
class AudioSendConfigReadWriteTest : public ConfigReadWriteTest {
public:
AudioSendConfigReadWriteTest() {}
- void GenerateConfig(uint32_t extensions_bitvector) override {
- GenerateAudioSendConfig(extensions_bitvector, &config, &prng);
+ void GenerateConfig(const RtpHeaderExtensionMap& extensions) override {
+ GenerateAudioSendConfig(extensions, &config, &prng);
}
void LogConfig(RtcEventLog* event_log) override {
event_log->LogAudioSendStreamConfig(config);
@@ -802,8 +1091,8 @@ class AudioSendConfigReadWriteTest : public ConfigReadWriteTest {
class VideoReceiveConfigReadWriteTest : public ConfigReadWriteTest {
public:
VideoReceiveConfigReadWriteTest() {}
- void GenerateConfig(uint32_t extensions_bitvector) override {
- GenerateVideoReceiveConfig(extensions_bitvector, &config, &prng);
+ void GenerateConfig(const RtpHeaderExtensionMap& extensions) override {
+ GenerateVideoReceiveConfig(extensions, &config, &prng);
}
void LogConfig(RtcEventLog* event_log) override {
event_log->LogVideoReceiveStreamConfig(config);
@@ -819,8 +1108,8 @@ class VideoReceiveConfigReadWriteTest : public ConfigReadWriteTest {
class VideoSendConfigReadWriteTest : public ConfigReadWriteTest {
public:
VideoSendConfigReadWriteTest() {}
- void GenerateConfig(uint32_t extensions_bitvector) override {
- GenerateVideoSendConfig(extensions_bitvector, &config, &prng);
+ void GenerateConfig(const RtpHeaderExtensionMap& extensions) override {
+ GenerateVideoSendConfig(extensions, &config, &prng);
}
void LogConfig(RtcEventLog* event_log) override {
event_log->LogVideoSendStreamConfig(config);
@@ -835,8 +1124,8 @@ class VideoSendConfigReadWriteTest : public ConfigReadWriteTest {
class AudioNetworkAdaptationReadWriteTest : public ConfigReadWriteTest {
public:
- void GenerateConfig(uint32_t extensions_bitvector) override {
- GenerateAudioNetworkAdaptation(extensions_bitvector, &config, &prng);
+ void GenerateConfig(const RtpHeaderExtensionMap& extensions) override {
+ GenerateAudioNetworkAdaptation(extensions, &config, &prng);
}
void LogConfig(RtcEventLog* event_log) override {
event_log->LogAudioNetworkAdaptation(config);
« no previous file with comments | « webrtc/logging/rtc_event_log/rtc_event_log.cc ('k') | webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698