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