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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: logging/rtc_event_log/rtc_event_log_unittest.cc

Issue 2997973002: Split LogRtpHeader and LogRtcpPacket into separate versions for incoming and outgoing packets.
Patch Set: Split VerifyRtpEvent into one incoming and one outgoing version. 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
« no previous file with comments | « logging/rtc_event_log/rtc_event_log.cc ('k') | logging/rtc_event_log/rtc_event_log_unittest_helper.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: logging/rtc_event_log/rtc_event_log_unittest.cc
diff --git a/logging/rtc_event_log/rtc_event_log_unittest.cc b/logging/rtc_event_log/rtc_event_log_unittest.cc
index 7624420ede790fdc5be2e0ea648592dc7cd08201..f1fa43493704513f3a651dfbfc0199908e277891 100644
--- a/logging/rtc_event_log/rtc_event_log_unittest.cc
+++ b/logging/rtc_event_log/rtc_event_log_unittest.cc
@@ -10,6 +10,7 @@
#include <map>
#include <memory>
+#include <ostream>
#include <string>
#include <utility>
#include <vector>
@@ -25,11 +26,14 @@
#include "modules/rtp_rtcp/source/rtcp_packet.h"
#include "modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
+#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
#include "rtc_base/buffer.h"
#include "rtc_base/checks.h"
#include "rtc_base/fakeclock.h"
+#include "rtc_base/ptr_util.h"
#include "rtc_base/random.h"
+#include "system_wrappers/include/sleep.h" // TODO(terelius): Remove this.
#include "test/gtest.h"
#include "test/testsupport/fileutils.h"
@@ -44,72 +48,105 @@ 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");
-}
+// TODO(terelius): Merge with event type in parser once updated?
+enum class EventType {
+ kIncomingRtp,
+ kOutgoingRtp,
+ kIncomingRtcp,
+ kOutgoingRtcp,
+ kAudioPlayout,
+ kBweLossUpdate,
+ kBweDelayUpdate,
+ kVideoRecvConfig,
+ kVideoSendConfig,
+ kAudioRecvConfig,
+ kAudioSendConfig,
+ kAudioNetworkAdaptation,
+ kBweProbeClusterCreated,
+ kBweProbeResult,
+};
+
+const std::map<EventType, std::string> event_type_to_string(
+ {{EventType::kIncomingRtp, "RTP(in)"},
+ {EventType::kOutgoingRtp, "RTP(out)"},
+ {EventType::kIncomingRtcp, "RTCP(in)"},
+ {EventType::kOutgoingRtcp, "RTCP(out)"},
+ {EventType::kAudioPlayout, "PLAYOUT"},
+ {EventType::kBweLossUpdate, "BWE_LOSS"},
+ {EventType::kBweDelayUpdate, "BWE_DELAY"},
+ {EventType::kVideoRecvConfig, "VIDEO_RECV_CONFIG"},
+ {EventType::kVideoSendConfig, "VIDEO_SEND_CONFIG"},
+ {EventType::kAudioRecvConfig, "AUDIO_RECV_CONFIG"},
+ {EventType::kAudioSendConfig, "AUDIO_SEND_CONFIG"},
+ {EventType::kAudioNetworkAdaptation, "AUDIO_NETWORK_ADAPTATION"},
+ {EventType::kBweProbeClusterCreated, "BWE_PROBE_CREATED"},
+ {EventType::kBweProbeResult, "BWE_PROBE_RESULT"}});
+
+const std::map<ParsedRtcEventLog::EventType, std::string>
+ parsed_event_type_to_string(
+ {{ParsedRtcEventLog::EventType::UNKNOWN_EVENT, "UNKNOWN_EVENT"},
+ {ParsedRtcEventLog::EventType::LOG_START, "LOG_START"},
+ {ParsedRtcEventLog::EventType::LOG_END, "LOG_END"},
+ {ParsedRtcEventLog::EventType::RTP_EVENT, "RTP"},
+ {ParsedRtcEventLog::EventType::RTCP_EVENT, "RTCP"},
+ {ParsedRtcEventLog::EventType::AUDIO_PLAYOUT_EVENT, "AUDIO_PLAYOUT"},
+ {ParsedRtcEventLog::EventType::LOSS_BASED_BWE_UPDATE,
+ "LOSS_BASED_BWE_UPDATE"},
+ {ParsedRtcEventLog::EventType::DELAY_BASED_BWE_UPDATE,
+ "DELAY_BASED_BWE_UPDATE"},
+ {ParsedRtcEventLog::EventType::VIDEO_RECEIVER_CONFIG_EVENT,
+ "VIDEO_RECV_CONFIG"},
+ {ParsedRtcEventLog::EventType::VIDEO_SENDER_CONFIG_EVENT,
+ "VIDEO_SEND_CONFIG"},
+ {ParsedRtcEventLog::EventType::AUDIO_RECEIVER_CONFIG_EVENT,
+ "AUDIO_RECV_CONFIG"},
+ {ParsedRtcEventLog::EventType::AUDIO_SENDER_CONFIG_EVENT,
+ "AUDIO_SEND_CONFIG"},
+ {ParsedRtcEventLog::EventType::AUDIO_NETWORK_ADAPTATION_EVENT,
+ "AUDIO_NETWORK_ADAPTATION"},
+ {ParsedRtcEventLog::EventType::BWE_PROBE_CLUSTER_CREATED_EVENT,
+ "BWE_PROBE_CREATED"},
+ {ParsedRtcEventLog::EventType::BWE_PROBE_RESULT_EVENT,
+ "BWE_PROBE_RESULT"}});
} // 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) {
+void PrintActualEvents(const ParsedRtcEventLog& parsed_log,
+ std::ostream& stream);
+
+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 +176,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 +202,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 +217,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 +233,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 +248,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,212 +289,433 @@ 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;
-
- Random prng(random_seed);
-
- // 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);
- }
- }
- // Create rtp_count RTP packets containing random data.
- for (size_t i = 0; i < rtp_count; i++) {
- size_t packet_size = prng.Rand(1000, 1100);
- rtp_packets.push_back(
- GenerateRtpPacket(&extensions, csrcs_count, packet_size, &prng));
- }
- // Create rtcp_count RTCP packets containing random data.
- for (size_t i = 0; i < rtcp_count; i++) {
- rtcp_packets.push_back(GenerateRtcpPacket(&prng));
- }
- // Create playout_count 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>());
- }
- // Create bwe_loss_count 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>()));
- }
- // Create configurations for the video streams.
- GenerateVideoReceiveConfig(extensions_bitvector, &receiver_config, &prng);
- GenerateVideoSendConfig(extensions_bitvector, &sender_config, &prng);
- const int config_count = 2;
-
- // 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();
+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(std::ostream& stream);
+
+ 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;
+};
- // 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);
- 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) {
- 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));
- }
- }
- log_dumper->StopLogging();
- }
+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.push_back(rtclog::StreamConfig());
+ // GenerateVideoReceiveConfig(extensions, &receiver_configs.back(), &prng);
+ // event_types.push_back(EventType::kVideoRecvConfig);
+
+ // // Create configuration for the video send stream.
+ // sender_configs.push_back(rtclog::StreamConfig());
+ // GenerateVideoSendConfig(extensions, &sender_configs.back(), &prng);
+ // event_types.push_back(EventType::kVideoSendConfig);
+ // 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::kIncomingRtp);
+ // }
+ // for (size_t i = 0; i < outgoing_rtp_count; i++) {
+ // size_t packet_size = prng.Rand(1000, 1100);
+ // outgoing_rtp_packets.push_back(GenerateOutgoingRtpPacket(
+ // &extensions, csrcs_count, packet_size, &prng));
+ // event_types.push_back(EventType::kOutgoingRtp);
+ // }
+ // // 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::kIncomingRtcp);
+ // }
+ // for (size_t i = 0; i < outgoing_rtcp_count; i++) {
+ // outgoing_rtcp_packets.push_back(GenerateRtcpPacket(&prng));
+ // event_types.push_back(EventType::kOutgoingRtcp);
+ // }
+ // // 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::kAudioPlayout);
+ // }
+ // // Create random bitrate updates for LossBasedBwe.
+ // for (size_t i = 0; i < bwe_loss_count; i++) {
+ // bwe_loss_updates.push_back(GenerateBweLossEvent(&prng));
+ // event_types.push_back(EventType::kBweLossUpdate);
+ // }
+ // // 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::kBweDelayUpdate);
+ // }
+
+ // // 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));
+ // RTC_CHECK(i <= other && other < event_types.size());
+ // std::swap(event_types[i], event_types[other]);
+ // }
+}
- // Read the generated file from disk.
- ParsedRtcEventLog parsed_log;
+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.
+ // 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));
+ // if (i == event_types.size() / 2)
+ // log_dumper->StartLogging(temp_filename, 10000000);
+ // switch (event_types[i]) {
+ // case EventType::kIncomingRtp:
+ // RTC_CHECK(incoming_rtp_written < incoming_rtp_packets.size());
+ // log_dumper->LogIncomingRtpHeader(
+ // incoming_rtp_packets[incoming_rtp_written++]);
+ // break;
+ // case EventType::kOutgoingRtp:
+ // RTC_CHECK(outgoing_rtp_written < outgoing_rtp_packets.size());
+ // log_dumper->LogOutgoingRtpHeader(
+ // outgoing_rtp_packets[outgoing_rtp_written++],
+ // PacedPacketInfo::kNotAProbe);
+ // break;
+ // case EventType::kIncomingRtcp:
+ // RTC_CHECK(incoming_rtcp_written < incoming_rtcp_packets.size());
+ // log_dumper->LogIncomingRtcpPacket(
+ // incoming_rtcp_packets[incoming_rtcp_written++]);
+ // break;
+ // case EventType::kOutgoingRtcp:
+ // RTC_CHECK(outgoing_rtcp_written < outgoing_rtcp_packets.size());
+ // log_dumper->LogOutgoingRtcpPacket(
+ // outgoing_rtcp_packets[outgoing_rtcp_written++]);
+ // break;
+ // case EventType::kAudioPlayout:
+ // RTC_CHECK(playouts_written < playout_ssrcs.size());
+ // log_dumper->LogAudioPlayout(playout_ssrcs[playouts_written++]);
+ // break;
+ // case EventType::kBweLossUpdate:
+ // RTC_CHECK(bwe_loss_written < bwe_loss_updates.size());
+ // log_dumper->LogLossBasedBweUpdate(
+ // 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::kBweDelayUpdate:
+ // RTC_CHECK(bwe_delay_written < bwe_delay_updates.size());
+ // log_dumper->LogDelayBasedBweUpdate(
+ // bwe_delay_updates[bwe_delay_written].first,
+ // bwe_delay_updates[bwe_delay_written].second);
+ // bwe_delay_written++;
+ // break;
+ // case EventType::kVideoRecvConfig:
+ // RTC_CHECK(recv_configs_written < receiver_configs.size());
+ // log_dumper->LogVideoReceiveStreamConfig(
+ // receiver_configs[recv_configs_written++]);
+ // break;
+ // case EventType::kVideoSendConfig:
+ // RTC_CHECK(send_configs_written < sender_configs.size());
+ // log_dumper->LogVideoSendStreamConfig(
+ // sender_configs[send_configs_written++]);
+ // break;
+ // case EventType::kAudioRecvConfig:
+ // // Not implemented
+ // RTC_NOTREACHED();
+ // break;
+ // case EventType::kAudioSendConfig:
+ // // Not implemented
+ // RTC_NOTREACHED();
+ // break;
+ // case EventType::kAudioNetworkAdaptation:
+ // // Not implemented
+ // RTC_NOTREACHED();
+ // break;
+ // case EventType::kBweProbeClusterCreated:
+ // // Not implemented
+ // RTC_NOTREACHED();
+ // break;
+ // case EventType::kBweProbeResult:
+ // // Not implemented
+ // RTC_NOTREACHED();
+ // break;
+ // }
+ // }
+
+ // log_dumper->StopLogging();
+}
- ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
+// 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;
+
+ // RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0);
+
+ // for (size_t i = 0; i < event_types.size(); i++) {
+ // switch (event_types[i]) {
+ // case EventType::kIncomingRtp:
+ // RTC_CHECK(incoming_rtp_read < incoming_rtp_packets.size());
+ // RtcEventLogTestHelper::VerifyRtpEvent(
+ // parsed_log, i + 1, kIncomingPacket,
+ // incoming_rtp_packets[incoming_rtp_read++]);
+ // break;
+ // case EventType::kOutgoingRtp:
+ // RTC_CHECK(outgoing_rtp_read < outgoing_rtp_packets.size());
+ // RtcEventLogTestHelper::VerifyRtpEvent(
+ // parsed_log, i + 1, kOutgoingPacket,
+ // outgoing_rtp_packets[outgoing_rtp_read++]);
+ // break;
+ // case EventType::kIncomingRtcp:
+ // RTC_CHECK(incoming_rtcp_read < incoming_rtcp_packets.size());
+ // 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::kOutgoingRtcp:
+ // RTC_CHECK(outgoing_rtcp_read < outgoing_rtcp_packets.size());
+ // 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::kAudioPlayout:
+ // RTC_CHECK(playouts_read < playout_ssrcs.size());
+ // RtcEventLogTestHelper::VerifyPlayoutEvent(
+ // parsed_log, i + 1, playout_ssrcs[playouts_read++]);
+ // break;
+ // case EventType::kBweLossUpdate:
+ // RTC_CHECK(bwe_loss_read < bwe_loss_updates.size());
+ // 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::kBweDelayUpdate:
+ // RTC_CHECK(bwe_delay_read < bwe_delay_updates.size());
+ // 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::kVideoRecvConfig:
+ // RTC_CHECK(recv_configs_read < receiver_configs.size());
+ // RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(
+ // parsed_log, i + 1, receiver_configs[recv_configs_read++]);
+ // break;
+ // case EventType::kVideoSendConfig:
+ // RTC_CHECK(send_configs_read < sender_configs.size());
+ // RtcEventLogTestHelper::VerifyVideoSendStreamConfig(
+ // parsed_log, i + 1, sender_configs[send_configs_read++]);
+ // break;
+ // case EventType::kAudioRecvConfig:
+ // // Not implemented
+ // RTC_NOTREACHED();
+ // break;
+ // case EventType::kAudioSendConfig:
+ // // Not implemented
+ // RTC_NOTREACHED();
+ // break;
+ // case EventType::kAudioNetworkAdaptation:
+ // // Not implemented
+ // RTC_NOTREACHED();
+ // break;
+ // case EventType::kBweProbeClusterCreated:
+ // // Not implemented
+ // RTC_NOTREACHED();
+ // break;
+ // case EventType::kBweProbeResult:
+ // // 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());
+}
- // 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++;
- }
- }
+void SessionDescription::PrintExpectedEvents(std::ostream& stream) {
+ // for (size_t i = 0; i < event_types.size(); i++) {
+ // auto it = event_type_to_string.find(event_types[i]);
+ // RTC_CHECK(it != event_type_to_string.end());
+ // stream << it->second << " ";
+ // }
+ // stream << std::endl;
+}
- // Clean up temporary file - can be pretty slow.
- remove(temp_filename.c_str());
+void PrintActualEvents(const ParsedRtcEventLog& parsed_log,
+ std::ostream& stream) {
+ // for (size_t i = 0; i < parsed_log.GetNumberOfEvents(); i++) {
+ // auto it = parsed_event_type_to_string.find(parsed_log.GetEventType(i));
+ // RTC_CHECK(it != parsed_event_type_to_string.end());
+ // stream << it->second << " ";
+ // }
+ // stream << std::endl;
}
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);
-
- // 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;
- }
- }
- LogSessionAndReadBack(8, 2, 0, 0, extensions, 0, 3141592653u);
-
- extensions = (1u << kNumExtensions) - 1; // Enable all header extensions.
- LogSessionAndReadBack(9, 2, 3, 2, extensions, 2, 2718281828u);
-
- // Try all combinations of header extensions and up to 2 CSRCS.
- for (extensions = 0; extensions < (1u << kNumExtensions); extensions++) {
- 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.
- }
- }
+ 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();
+
+ printf("Test finished - sleeping\n");
+ fflush(stdout);
+ SleepMs(1000);
+ printf("Waking up and leaving test\n");
+ fflush(stdout);
}
+// 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 (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++) {
+// 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();
+// }
+// }
+// }
+
TEST(RtcEventLogTest, LogEventAndReadBack) {
Random prng(987654321);
// 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 +729,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 +750,7 @@ 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::VerifyIncomingRtpEvent(parsed_log, 1, rtp_packet);
RtcEventLogTestHelper::VerifyRtcpEvent(
parsed_log, 2, kOutgoingPacket, rtcp_packet.data(), rtcp_packet.size());
@@ -721,7 +995,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 +1008,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 +1045,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 +1062,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 +1079,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 +1096,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 +1112,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 | « logging/rtc_event_log/rtc_event_log.cc ('k') | 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