| /* |
| * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. |
| * |
| * Use of this source code is governed by a BSD-style license |
| * that can be found in the LICENSE file in the root of the source |
| * tree. An additional intellectual property rights grant can be found |
| * in the file PATENTS. All contributing project authors may |
| * be found in the AUTHORS file in the root of the source tree. |
| */ |
| |
| #ifdef ENABLE_RTC_EVENT_LOG |
| |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "webrtc/base/buffer.h" |
| #include "webrtc/base/checks.h" |
| #include "webrtc/base/random.h" |
| #include "webrtc/base/scoped_ptr.h" |
| #include "webrtc/base/thread.h" |
| #include "webrtc/call.h" |
| #include "webrtc/call/rtc_event_log.h" |
| #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h" |
| #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h" |
| #include "webrtc/system_wrappers/include/clock.h" |
| #include "webrtc/test/test_suite.h" |
| #include "webrtc/test/testsupport/fileutils.h" |
| |
| // Files generated at build-time by the protobuf compiler. |
| #ifdef WEBRTC_ANDROID_PLATFORM_BUILD |
| #include "external/webrtc/webrtc/call/rtc_event_log.pb.h" |
| #else |
| #include "webrtc/call/rtc_event_log.pb.h" |
| #endif |
| |
| namespace webrtc { |
| |
| namespace { |
| |
| const RTPExtensionType kExtensionTypes[] = { |
| RTPExtensionType::kRtpExtensionTransmissionTimeOffset, |
| RTPExtensionType::kRtpExtensionAudioLevel, |
| RTPExtensionType::kRtpExtensionAbsoluteSendTime, |
| RTPExtensionType::kRtpExtensionVideoRotation, |
| RTPExtensionType::kRtpExtensionTransportSequenceNumber}; |
| const char* kExtensionNames[] = {RtpExtension::kTOffset, |
| RtpExtension::kAudioLevel, |
| RtpExtension::kAbsSendTime, |
| RtpExtension::kVideoRotation, |
| RtpExtension::kTransportSequenceNumber}; |
| const size_t kNumExtensions = 5; |
| |
| } // namespace |
| |
| // TODO(terelius): Place this definition with other parsing functions? |
| MediaType GetRuntimeMediaType(rtclog::MediaType media_type) { |
| switch (media_type) { |
| case rtclog::MediaType::ANY: |
| return MediaType::ANY; |
| case rtclog::MediaType::AUDIO: |
| return MediaType::AUDIO; |
| case rtclog::MediaType::VIDEO: |
| return MediaType::VIDEO; |
| case rtclog::MediaType::DATA: |
| return MediaType::DATA; |
| } |
| RTC_NOTREACHED(); |
| return MediaType::ANY; |
| } |
| |
| // Checks that the event has a timestamp, a type and exactly the data field |
| // corresponding to the type. |
| ::testing::AssertionResult IsValidBasicEvent(const rtclog::Event& event) { |
| if (!event.has_timestamp_us()) |
| return ::testing::AssertionFailure() << "Event has no timestamp"; |
| if (!event.has_type()) |
| return ::testing::AssertionFailure() << "Event has no event type"; |
| rtclog::Event_EventType type = event.type(); |
| if ((type == rtclog::Event::RTP_EVENT) != event.has_rtp_packet()) |
| return ::testing::AssertionFailure() |
| << "Event of type " << type << " has " |
| << (event.has_rtp_packet() ? "" : "no ") << "RTP packet"; |
| if ((type == rtclog::Event::RTCP_EVENT) != event.has_rtcp_packet()) |
| return ::testing::AssertionFailure() |
| << "Event of type " << type << " has " |
| << (event.has_rtcp_packet() ? "" : "no ") << "RTCP packet"; |
| if ((type == rtclog::Event::AUDIO_PLAYOUT_EVENT) != |
| event.has_audio_playout_event()) |
| return ::testing::AssertionFailure() |
| << "Event of type " << type << " has " |
| << (event.has_audio_playout_event() ? "" : "no ") |
| << "audio_playout event"; |
| if ((type == rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT) != |
| event.has_video_receiver_config()) |
| return ::testing::AssertionFailure() |
| << "Event of type " << type << " has " |
| << (event.has_video_receiver_config() ? "" : "no ") |
| << "receiver config"; |
| if ((type == rtclog::Event::VIDEO_SENDER_CONFIG_EVENT) != |
| event.has_video_sender_config()) |
| return ::testing::AssertionFailure() |
| << "Event of type " << type << " has " |
| << (event.has_video_sender_config() ? "" : "no ") << "sender config"; |
| if ((type == rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT) != |
| event.has_audio_receiver_config()) { |
| return ::testing::AssertionFailure() |
| << "Event of type " << type << " has " |
| << (event.has_audio_receiver_config() ? "" : "no ") |
| << "audio receiver config"; |
| } |
| if ((type == rtclog::Event::AUDIO_SENDER_CONFIG_EVENT) != |
| event.has_audio_sender_config()) { |
| return ::testing::AssertionFailure() |
| << "Event of type " << type << " has " |
| << (event.has_audio_sender_config() ? "" : "no ") |
| << "audio sender config"; |
| } |
| return ::testing::AssertionSuccess(); |
| } |
| |
| void VerifyReceiveStreamConfig(const rtclog::Event& event, |
| const VideoReceiveStream::Config& config) { |
| ASSERT_TRUE(IsValidBasicEvent(event)); |
| ASSERT_EQ(rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT, event.type()); |
| const rtclog::VideoReceiveConfig& receiver_config = |
| event.video_receiver_config(); |
| // Check SSRCs. |
| ASSERT_TRUE(receiver_config.has_remote_ssrc()); |
| EXPECT_EQ(config.rtp.remote_ssrc, receiver_config.remote_ssrc()); |
| ASSERT_TRUE(receiver_config.has_local_ssrc()); |
| EXPECT_EQ(config.rtp.local_ssrc, receiver_config.local_ssrc()); |
| // Check RTCP settings. |
| ASSERT_TRUE(receiver_config.has_rtcp_mode()); |
| if (config.rtp.rtcp_mode == RtcpMode::kCompound) |
| EXPECT_EQ(rtclog::VideoReceiveConfig::RTCP_COMPOUND, |
| receiver_config.rtcp_mode()); |
| else |
| EXPECT_EQ(rtclog::VideoReceiveConfig::RTCP_REDUCEDSIZE, |
| receiver_config.rtcp_mode()); |
| ASSERT_TRUE(receiver_config.has_remb()); |
| EXPECT_EQ(config.rtp.remb, receiver_config.remb()); |
| // Check RTX map. |
| ASSERT_EQ(static_cast<int>(config.rtp.rtx.size()), |
| receiver_config.rtx_map_size()); |
| for (const rtclog::RtxMap& rtx_map : receiver_config.rtx_map()) { |
| ASSERT_TRUE(rtx_map.has_payload_type()); |
| ASSERT_TRUE(rtx_map.has_config()); |
| EXPECT_EQ(1u, config.rtp.rtx.count(rtx_map.payload_type())); |
| const rtclog::RtxConfig& rtx_config = rtx_map.config(); |
| const VideoReceiveStream::Config::Rtp::Rtx& rtx = |
| config.rtp.rtx.at(rtx_map.payload_type()); |
| ASSERT_TRUE(rtx_config.has_rtx_ssrc()); |
| ASSERT_TRUE(rtx_config.has_rtx_payload_type()); |
| EXPECT_EQ(rtx.ssrc, rtx_config.rtx_ssrc()); |
| EXPECT_EQ(rtx.payload_type, rtx_config.rtx_payload_type()); |
| } |
| // Check header extensions. |
| ASSERT_EQ(static_cast<int>(config.rtp.extensions.size()), |
| receiver_config.header_extensions_size()); |
| for (int i = 0; i < receiver_config.header_extensions_size(); i++) { |
| ASSERT_TRUE(receiver_config.header_extensions(i).has_name()); |
| ASSERT_TRUE(receiver_config.header_extensions(i).has_id()); |
| const std::string& name = receiver_config.header_extensions(i).name(); |
| int id = receiver_config.header_extensions(i).id(); |
| EXPECT_EQ(config.rtp.extensions[i].id, id); |
| EXPECT_EQ(config.rtp.extensions[i].name, name); |
| } |
| // Check decoders. |
| ASSERT_EQ(static_cast<int>(config.decoders.size()), |
| receiver_config.decoders_size()); |
| for (int i = 0; i < receiver_config.decoders_size(); i++) { |
| ASSERT_TRUE(receiver_config.decoders(i).has_name()); |
| ASSERT_TRUE(receiver_config.decoders(i).has_payload_type()); |
| const std::string& decoder_name = receiver_config.decoders(i).name(); |
| int decoder_type = receiver_config.decoders(i).payload_type(); |
| EXPECT_EQ(config.decoders[i].payload_name, decoder_name); |
| EXPECT_EQ(config.decoders[i].payload_type, decoder_type); |
| } |
| } |
| |
| void VerifySendStreamConfig(const rtclog::Event& event, |
| const VideoSendStream::Config& config) { |
| ASSERT_TRUE(IsValidBasicEvent(event)); |
| ASSERT_EQ(rtclog::Event::VIDEO_SENDER_CONFIG_EVENT, event.type()); |
| const rtclog::VideoSendConfig& sender_config = event.video_sender_config(); |
| // Check SSRCs. |
| ASSERT_EQ(static_cast<int>(config.rtp.ssrcs.size()), |
| sender_config.ssrcs_size()); |
| for (int i = 0; i < sender_config.ssrcs_size(); i++) { |
| EXPECT_EQ(config.rtp.ssrcs[i], sender_config.ssrcs(i)); |
| } |
| // Check header extensions. |
| ASSERT_EQ(static_cast<int>(config.rtp.extensions.size()), |
| sender_config.header_extensions_size()); |
| for (int i = 0; i < sender_config.header_extensions_size(); i++) { |
| ASSERT_TRUE(sender_config.header_extensions(i).has_name()); |
| ASSERT_TRUE(sender_config.header_extensions(i).has_id()); |
| const std::string& name = sender_config.header_extensions(i).name(); |
| int id = sender_config.header_extensions(i).id(); |
| EXPECT_EQ(config.rtp.extensions[i].id, id); |
| EXPECT_EQ(config.rtp.extensions[i].name, name); |
| } |
| // Check RTX settings. |
| ASSERT_EQ(static_cast<int>(config.rtp.rtx.ssrcs.size()), |
| sender_config.rtx_ssrcs_size()); |
| for (int i = 0; i < sender_config.rtx_ssrcs_size(); i++) { |
| EXPECT_EQ(config.rtp.rtx.ssrcs[i], sender_config.rtx_ssrcs(i)); |
| } |
| if (sender_config.rtx_ssrcs_size() > 0) { |
| ASSERT_TRUE(sender_config.has_rtx_payload_type()); |
| EXPECT_EQ(config.rtp.rtx.payload_type, sender_config.rtx_payload_type()); |
| } |
| // Check encoder. |
| ASSERT_TRUE(sender_config.has_encoder()); |
| ASSERT_TRUE(sender_config.encoder().has_name()); |
| ASSERT_TRUE(sender_config.encoder().has_payload_type()); |
| EXPECT_EQ(config.encoder_settings.payload_name, |
| sender_config.encoder().name()); |
| EXPECT_EQ(config.encoder_settings.payload_type, |
| sender_config.encoder().payload_type()); |
| } |
| |
| void VerifyRtpEvent(const rtclog::Event& event, |
| bool incoming, |
| MediaType media_type, |
| const uint8_t* header, |
| size_t header_size, |
| size_t total_size) { |
| ASSERT_TRUE(IsValidBasicEvent(event)); |
| ASSERT_EQ(rtclog::Event::RTP_EVENT, event.type()); |
| const rtclog::RtpPacket& rtp_packet = event.rtp_packet(); |
| ASSERT_TRUE(rtp_packet.has_incoming()); |
| EXPECT_EQ(incoming, rtp_packet.incoming()); |
| ASSERT_TRUE(rtp_packet.has_type()); |
| EXPECT_EQ(media_type, GetRuntimeMediaType(rtp_packet.type())); |
| ASSERT_TRUE(rtp_packet.has_packet_length()); |
| EXPECT_EQ(total_size, rtp_packet.packet_length()); |
| ASSERT_TRUE(rtp_packet.has_header()); |
| ASSERT_EQ(header_size, rtp_packet.header().size()); |
| for (size_t i = 0; i < header_size; i++) { |
| EXPECT_EQ(header[i], static_cast<uint8_t>(rtp_packet.header()[i])); |
| } |
| } |
| |
| void VerifyRtcpEvent(const rtclog::Event& event, |
| bool incoming, |
| MediaType media_type, |
| const uint8_t* packet, |
| size_t total_size) { |
| ASSERT_TRUE(IsValidBasicEvent(event)); |
| ASSERT_EQ(rtclog::Event::RTCP_EVENT, event.type()); |
| const rtclog::RtcpPacket& rtcp_packet = event.rtcp_packet(); |
| ASSERT_TRUE(rtcp_packet.has_incoming()); |
| EXPECT_EQ(incoming, rtcp_packet.incoming()); |
| ASSERT_TRUE(rtcp_packet.has_type()); |
| EXPECT_EQ(media_type, GetRuntimeMediaType(rtcp_packet.type())); |
| ASSERT_TRUE(rtcp_packet.has_packet_data()); |
| ASSERT_EQ(total_size, rtcp_packet.packet_data().size()); |
| for (size_t i = 0; i < total_size; i++) { |
| EXPECT_EQ(packet[i], static_cast<uint8_t>(rtcp_packet.packet_data()[i])); |
| } |
| } |
| |
| void VerifyPlayoutEvent(const rtclog::Event& event, uint32_t ssrc) { |
| ASSERT_TRUE(IsValidBasicEvent(event)); |
| ASSERT_EQ(rtclog::Event::AUDIO_PLAYOUT_EVENT, event.type()); |
| const rtclog::AudioPlayoutEvent& playout_event = event.audio_playout_event(); |
| ASSERT_TRUE(playout_event.has_local_ssrc()); |
| EXPECT_EQ(ssrc, playout_event.local_ssrc()); |
| } |
| |
| void VerifyBweLossEvent(const rtclog::Event& event, |
| int32_t bitrate, |
| uint8_t fraction_loss, |
| int32_t total_packets) { |
| ASSERT_TRUE(IsValidBasicEvent(event)); |
| ASSERT_EQ(rtclog::Event::BWE_PACKET_LOSS_EVENT, event.type()); |
| const rtclog::BwePacketLossEvent& bwe_event = event.bwe_packet_loss_event(); |
| ASSERT_TRUE(bwe_event.has_bitrate()); |
| EXPECT_EQ(bitrate, bwe_event.bitrate()); |
| ASSERT_TRUE(bwe_event.has_fraction_loss()); |
| EXPECT_EQ(fraction_loss, bwe_event.fraction_loss()); |
| ASSERT_TRUE(bwe_event.has_total_packets()); |
| EXPECT_EQ(total_packets, bwe_event.total_packets()); |
| } |
| |
| void VerifyLogStartEvent(const rtclog::Event& event) { |
| ASSERT_TRUE(IsValidBasicEvent(event)); |
| EXPECT_EQ(rtclog::Event::LOG_START, event.type()); |
| } |
| |
| /* |
| * 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. |
| */ |
| size_t GenerateRtpPacket(uint32_t extensions_bitvector, |
| uint32_t csrcs_count, |
| uint8_t* packet, |
| size_t packet_size, |
| Random* prng) { |
| RTC_CHECK_GE(packet_size, 16 + 4 * csrcs_count + 4 * kNumExtensions); |
| Clock* clock = Clock::GetRealTimeClock(); |
| |
| RTPSender rtp_sender(false, // bool audio |
| clock, // Clock* clock |
| nullptr, // Transport* |
| nullptr, // RtpAudioFeedback* |
| nullptr, // PacedSender* |
| nullptr, // PacketRouter* |
| nullptr, // SendTimeObserver* |
| nullptr, // BitrateStatisticsObserver* |
| nullptr, // FrameCountObserver* |
| nullptr); // SendSideDelayObserver* |
| |
| std::vector<uint32_t> csrcs; |
| for (unsigned i = 0; i < csrcs_count; i++) { |
| csrcs.push_back(prng->Rand<uint32_t>()); |
| } |
| rtp_sender.SetCsrcs(csrcs); |
| rtp_sender.SetSSRC(prng->Rand<uint32_t>()); |
| rtp_sender.SetStartTimestamp(prng->Rand<uint32_t>(), true); |
| rtp_sender.SetSequenceNumber(prng->Rand<uint16_t>()); |
| |
| for (unsigned i = 0; i < kNumExtensions; i++) { |
| if (extensions_bitvector & (1u << i)) { |
| rtp_sender.RegisterRtpHeaderExtension(kExtensionTypes[i], i + 1); |
| } |
| } |
| |
| int8_t payload_type = prng->Rand(0, 127); |
| bool marker_bit = prng->Rand<bool>(); |
| uint32_t capture_timestamp = prng->Rand<uint32_t>(); |
| int64_t capture_time_ms = prng->Rand<uint32_t>(); |
| bool timestamp_provided = prng->Rand<bool>(); |
| bool inc_sequence_number = prng->Rand<bool>(); |
| |
| size_t header_size = rtp_sender.BuildRTPheader( |
| packet, payload_type, marker_bit, capture_timestamp, capture_time_ms, |
| timestamp_provided, inc_sequence_number); |
| |
| for (size_t i = header_size; i < packet_size; i++) { |
| packet[i] = prng->Rand<uint8_t>(); |
| } |
| |
| return header_size; |
| } |
| |
| rtc::scoped_ptr<rtcp::RawPacket> GenerateRtcpPacket(Random* prng) { |
| rtcp::ReportBlock report_block; |
| report_block.To(prng->Rand<uint32_t>()); // Remote SSRC. |
| report_block.WithFractionLost(prng->Rand(50)); |
| |
| rtcp::SenderReport sender_report; |
| sender_report.From(prng->Rand<uint32_t>()); // Sender SSRC. |
| sender_report.WithNtpSec(prng->Rand<uint32_t>()); |
| sender_report.WithNtpFrac(prng->Rand<uint32_t>()); |
| sender_report.WithPacketCount(prng->Rand<uint32_t>()); |
| sender_report.WithReportBlock(report_block); |
| |
| return sender_report.Build(); |
| } |
| |
| void GenerateVideoReceiveConfig(uint32_t extensions_bitvector, |
| VideoReceiveStream::Config* config, |
| Random* prng) { |
| // Create a map from a payload type to an encoder name. |
| VideoReceiveStream::Decoder decoder; |
| decoder.payload_type = prng->Rand(0, 127); |
| decoder.payload_name = (prng->Rand<bool>() ? "VP8" : "H264"); |
| config->decoders.push_back(decoder); |
| // Add SSRCs for the stream. |
| config->rtp.remote_ssrc = prng->Rand<uint32_t>(); |
| config->rtp.local_ssrc = prng->Rand<uint32_t>(); |
| // Add extensions and settings for RTCP. |
| config->rtp.rtcp_mode = |
| prng->Rand<bool>() ? RtcpMode::kCompound : RtcpMode::kReducedSize; |
| config->rtp.remb = prng->Rand<bool>(); |
| // Add a map from a payload type to a new ssrc and a new payload type for RTX. |
| VideoReceiveStream::Config::Rtp::Rtx rtx_pair; |
| rtx_pair.ssrc = prng->Rand<uint32_t>(); |
| rtx_pair.payload_type = prng->Rand(0, 127); |
| config->rtp.rtx.insert(std::make_pair(prng->Rand(0, 127), rtx_pair)); |
| // 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>())); |
| } |
| } |
| } |
| |
| void GenerateVideoSendConfig(uint32_t extensions_bitvector, |
| VideoSendStream::Config* config, |
| Random* prng) { |
| // Create a map from a payload type to an encoder name. |
| config->encoder_settings.payload_type = prng->Rand(0, 127); |
| config->encoder_settings.payload_name = (prng->Rand<bool>() ? "VP8" : "H264"); |
| // Add SSRCs for the stream. |
| config->rtp.ssrcs.push_back(prng->Rand<uint32_t>()); |
| // Add a map from a payload type to new ssrcs and a new payload type for RTX. |
| config->rtp.rtx.ssrcs.push_back(prng->Rand<uint32_t>()); |
| config->rtp.rtx.payload_type = prng->Rand(0, 127); |
| // 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>())); |
| } |
| } |
| } |
| |
| // 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<rtc::Buffer> rtp_packets; |
| std::vector<rtc::scoped_ptr<rtcp::RawPacket> > rtcp_packets; |
| std::vector<size_t> rtp_header_sizes; |
| std::vector<uint32_t> playout_ssrcs; |
| std::vector<std::pair<int32_t, uint8_t> > bwe_loss_updates; |
| |
| VideoReceiveStream::Config receiver_config(nullptr); |
| VideoSendStream::Config sender_config(nullptr); |
| |
| Random prng(random_seed); |
| |
| // 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(rtc::Buffer(packet_size)); |
| size_t header_size = |
| GenerateRtpPacket(extensions_bitvector, csrcs_count, |
| rtp_packets[i].data(), packet_size, &prng); |
| rtp_header_sizes.push_back(header_size); |
| } |
| // 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 BwePacketLoss. |
| 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(); |
| |
| // When log_dumper goes out of scope, it causes the log file to be flushed |
| // to disk. |
| { |
| rtc::scoped_ptr<RtcEventLog> log_dumper(RtcEventLog::Create()); |
| log_dumper->LogVideoReceiveStreamConfig(receiver_config); |
| log_dumper->LogVideoSendStreamConfig(sender_config); |
| 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), // Every second packet is incoming. |
| (i % 3 == 0) ? MediaType::AUDIO : MediaType::VIDEO, |
| rtp_packets[i - 1].data(), rtp_packets[i - 1].size()); |
| if (i * rtcp_count >= rtcp_index * rtp_count) { |
| log_dumper->LogRtcpPacket( |
| rtcp_index % 2 == 0, // Every second packet is incoming |
| rtcp_index % 3 == 0 ? MediaType::AUDIO : MediaType::VIDEO, |
| rtcp_packets[rtcp_index - 1]->Buffer(), |
| rtcp_packets[rtcp_index - 1]->Length()); |
| rtcp_index++; |
| } |
| if (i * playout_count >= playout_index * rtp_count) { |
| log_dumper->LogAudioPlayout(playout_ssrcs[playout_index - 1]); |
| playout_index++; |
| } |
| if (i * bwe_loss_count >= bwe_loss_index * rtp_count) { |
| log_dumper->LogBwePacketLossEvent( |
| bwe_loss_updates[bwe_loss_index - 1].first, |
| bwe_loss_updates[bwe_loss_index - 1].second, i); |
| bwe_loss_index++; |
| } |
| if (i == rtp_count / 2) { |
| log_dumper->StartLogging(temp_filename, 10000000); |
| } |
| } |
| } |
| |
| // Read the generated file from disk. |
| rtclog::EventStream parsed_stream; |
| |
| ASSERT_TRUE(RtcEventLog::ParseRtcEventLog(temp_filename, &parsed_stream)); |
| |
| // 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 int event_count = config_count + playout_count + bwe_loss_count + |
| rtcp_count + rtp_count + 1; |
| EXPECT_EQ(event_count, parsed_stream.stream_size()); |
| VerifyReceiveStreamConfig(parsed_stream.stream(0), receiver_config); |
| VerifySendStreamConfig(parsed_stream.stream(1), sender_config); |
| size_t event_index = config_count; |
| 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++) { |
| VerifyRtpEvent(parsed_stream.stream(event_index), |
| (i % 2 == 0), // Every second packet is incoming. |
| (i % 3 == 0) ? MediaType::AUDIO : MediaType::VIDEO, |
| rtp_packets[i - 1].data(), rtp_header_sizes[i - 1], |
| rtp_packets[i - 1].size()); |
| event_index++; |
| if (i * rtcp_count >= rtcp_index * rtp_count) { |
| VerifyRtcpEvent(parsed_stream.stream(event_index), |
| rtcp_index % 2 == 0, // Every second packet is incoming. |
| rtcp_index % 3 == 0 ? MediaType::AUDIO : MediaType::VIDEO, |
| rtcp_packets[rtcp_index - 1]->Buffer(), |
| rtcp_packets[rtcp_index - 1]->Length()); |
| event_index++; |
| rtcp_index++; |
| } |
| if (i * playout_count >= playout_index * rtp_count) { |
| VerifyPlayoutEvent(parsed_stream.stream(event_index), |
| playout_ssrcs[playout_index - 1]); |
| event_index++; |
| playout_index++; |
| } |
| if (i * bwe_loss_count >= bwe_loss_index * rtp_count) { |
| VerifyBweLossEvent(parsed_stream.stream(event_index), |
| bwe_loss_updates[bwe_loss_index - 1].first, |
| bwe_loss_updates[bwe_loss_index - 1].second, i); |
| event_index++; |
| bwe_loss_index++; |
| } |
| if (i == rtp_count / 2) { |
| VerifyLogStartEvent(parsed_stream.stream(event_index)); |
| event_index++; |
| } |
| } |
| |
| // 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); |
| |
| // 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. |
| } |
| } |
| } |
| |
| // Tests that the event queue works correctly, i.e. drops old RTP, RTCP and |
| // debug events, but keeps config events even if they are older than the limit. |
| void DropOldEvents(uint32_t extensions_bitvector, |
| uint32_t csrcs_count, |
| unsigned int random_seed) { |
| rtc::Buffer old_rtp_packet; |
| rtc::Buffer recent_rtp_packet; |
| rtc::scoped_ptr<rtcp::RawPacket> old_rtcp_packet; |
| rtc::scoped_ptr<rtcp::RawPacket> recent_rtcp_packet; |
| |
| VideoReceiveStream::Config receiver_config(nullptr); |
| VideoSendStream::Config sender_config(nullptr); |
| |
| Random prng(random_seed); |
| |
| // Create two RTP packets containing random data. |
| size_t packet_size = prng.Rand(1000, 1100); |
| old_rtp_packet.SetSize(packet_size); |
| GenerateRtpPacket(extensions_bitvector, csrcs_count, old_rtp_packet.data(), |
| packet_size, &prng); |
| packet_size = prng.Rand(1000, 1100); |
| recent_rtp_packet.SetSize(packet_size); |
| size_t recent_header_size = |
| GenerateRtpPacket(extensions_bitvector, csrcs_count, |
| recent_rtp_packet.data(), packet_size, &prng); |
| |
| // Create two RTCP packets containing random data. |
| old_rtcp_packet = GenerateRtcpPacket(&prng); |
| recent_rtcp_packet = GenerateRtcpPacket(&prng); |
| |
| // Create configurations for the video streams. |
| GenerateVideoReceiveConfig(extensions_bitvector, &receiver_config, &prng); |
| GenerateVideoSendConfig(extensions_bitvector, &sender_config, &prng); |
| |
| // 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(); |
| |
| // The log file will be flushed to disk when the log_dumper goes out of scope. |
| { |
| rtc::scoped_ptr<RtcEventLog> log_dumper(RtcEventLog::Create()); |
| // Reduce the time old events are stored to 50 ms. |
| log_dumper->SetBufferDuration(50000); |
| log_dumper->LogVideoReceiveStreamConfig(receiver_config); |
| log_dumper->LogVideoSendStreamConfig(sender_config); |
| log_dumper->LogRtpHeader(false, MediaType::AUDIO, old_rtp_packet.data(), |
| old_rtp_packet.size()); |
| log_dumper->LogRtcpPacket(true, MediaType::AUDIO, old_rtcp_packet->Buffer(), |
| old_rtcp_packet->Length()); |
| // Sleep 55 ms to let old events be removed from the queue. |
| rtc::Thread::SleepMs(55); |
| log_dumper->StartLogging(temp_filename, 10000000); |
| log_dumper->LogRtpHeader(true, MediaType::VIDEO, recent_rtp_packet.data(), |
| recent_rtp_packet.size()); |
| log_dumper->LogRtcpPacket(false, MediaType::VIDEO, |
| recent_rtcp_packet->Buffer(), |
| recent_rtcp_packet->Length()); |
| } |
| |
| // Read the generated file from disk. |
| rtclog::EventStream parsed_stream; |
| ASSERT_TRUE(RtcEventLog::ParseRtcEventLog(temp_filename, &parsed_stream)); |
| |
| // Verify that what we read back from the event log is the same as |
| // what we wrote. Old RTP and RTCP events should have been discarded, |
| // but old configuration events should still be available. |
| EXPECT_EQ(5, parsed_stream.stream_size()); |
| VerifyReceiveStreamConfig(parsed_stream.stream(0), receiver_config); |
| VerifySendStreamConfig(parsed_stream.stream(1), sender_config); |
| VerifyLogStartEvent(parsed_stream.stream(2)); |
| VerifyRtpEvent(parsed_stream.stream(3), true, MediaType::VIDEO, |
| recent_rtp_packet.data(), recent_header_size, |
| recent_rtp_packet.size()); |
| VerifyRtcpEvent(parsed_stream.stream(4), false, MediaType::VIDEO, |
| recent_rtcp_packet->Buffer(), recent_rtcp_packet->Length()); |
| |
| // Clean up temporary file - can be pretty slow. |
| remove(temp_filename.c_str()); |
| } |
| |
| TEST(RtcEventLogTest, DropOldEvents) { |
| // Enable all header extensions |
| uint32_t extensions = (1u << kNumExtensions) - 1; |
| uint32_t csrcs_count = 2; |
| DropOldEvents(extensions, csrcs_count, 141421356); |
| DropOldEvents(extensions, csrcs_count, 173205080); |
| } |
| |
| } // namespace webrtc |
| |
| #endif // ENABLE_RTC_EVENT_LOG |
