Removed cname and receiver_reference_time_report from proto and logging code. Changed logging of RTCP to omit messages of type SDES and APP.

BUG=

Review URL: https://codereview.webrtc.org/1419523004

Cr-Commit-Position: refs/heads/master@{#10542}

webrtc/call/rtc_event_log.cc

@@ -17,7 +17,9 @@
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/call.h"
+#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/file_wrapper.h"
 
@@ -269,9 +271,6 @@ void RtcEventLogImpl::LogVideoReceiveStreamConfig(
   receiver_config->set_local_ssrc(config.rtp.local_ssrc);
 
   receiver_config->set_rtcp_mode(ConvertRtcpMode(config.rtp.rtcp_mode));
-
-  receiver_config->set_receiver_reference_time_report(
-      config.rtp.rtcp_xr.receiver_reference_time_report);
   receiver_config->set_remb(config.rtp.remb);
 
   for (const auto& kv : config.rtp.rtx) {
@@ -322,8 +321,6 @@ void RtcEventLogImpl::LogVideoSendStreamConfig(
   }
   sender_config->set_rtx_payload_type(config.rtp.rtx.payload_type);
 
-  sender_config->set_c_name(config.rtp.c_name);
-
   rtclog::EncoderConfig* encoder = sender_config->mutable_encoder();
   encoder->set_name(config.encoder_settings.payload_name);
   encoder->set_payload_type(config.encoder_settings.payload_type);
@@ -371,7 +368,52 @@ void RtcEventLogImpl::LogRtcpPacket(bool incoming,
   rtcp_event.set_type(rtclog::Event::RTCP_EVENT);
   rtcp_event.mutable_rtcp_packet()->set_incoming(incoming);
   rtcp_event.mutable_rtcp_packet()->set_type(ConvertMediaType(media_type));
-  rtcp_event.mutable_rtcp_packet()->set_packet_data(packet, length);
+
+  RTCPUtility::RtcpCommonHeader header;
+  const uint8_t* block_begin = packet;
+  const uint8_t* packet_end = packet + length;
+  RTC_DCHECK(length <= IP_PACKET_SIZE);
+  uint8_t buffer[IP_PACKET_SIZE];
+  uint32_t buffer_length = 0;
+  while (block_begin < packet_end) {
+    if (!RtcpParseCommonHeader(block_begin, packet_end - block_begin,
+                               &header)) {
+      break;  // Incorrect message header.
+    }
+    uint32_t block_size = header.BlockSize();
+    switch (header.packet_type) {
+      case RTCPUtility::PT_SR:
+        FALLTHROUGH();
+      case RTCPUtility::PT_RR:
+        FALLTHROUGH();
+      case RTCPUtility::PT_BYE:
+        FALLTHROUGH();
+      case RTCPUtility::PT_IJ:
+        FALLTHROUGH();
+      case RTCPUtility::PT_RTPFB:
+        FALLTHROUGH();
+      case RTCPUtility::PT_PSFB:
+        FALLTHROUGH();
+      case RTCPUtility::PT_XR:
+        // We log sender reports, receiver reports, bye messages
+        // inter-arrival jitter, third-party loss reports, payload-specific
+        // feedback and extended reports.
+        memcpy(buffer + buffer_length, block_begin, block_size);
+        buffer_length += block_size;
+        break;
+      case RTCPUtility::PT_SDES:
+        FALLTHROUGH();
+      case RTCPUtility::PT_APP:
+        FALLTHROUGH();
+      default:
+        // We don't log sender descriptions, application defined messages
+        // or message blocks of unknown type.
+        break;
+    }
+
+    block_begin += block_size;
+  }
+  rtcp_event.mutable_rtcp_packet()->set_packet_data(buffer, buffer_length);
   HandleEvent(&rtcp_event);
 }
 

webrtc/call/rtc_event_log.proto

@@ -137,20 +137,17 @@ message VideoReceiveConfig {
   // required - RTCP mode to use.
   optional RtcpMode rtcp_mode = 3;
 
-  // required - Extended RTCP settings.
-  optional bool receiver_reference_time_report = 4;
-
   // required - Receiver estimated maximum bandwidth.
-  optional bool remb = 5;
+  optional bool remb = 4;
 
   // Map from video RTP payload type -> RTX config.
-  repeated RtxMap rtx_map = 6;
+  repeated RtxMap rtx_map = 5;
 
   // RTP header extensions used for the received stream.
-  repeated RtpHeaderExtension header_extensions = 7;
+  repeated RtpHeaderExtension header_extensions = 6;
 
   // List of decoders associated with the stream.
-  repeated DecoderConfig decoders = 8;
+  repeated DecoderConfig decoders = 7;
 }
 
 
@@ -209,11 +206,8 @@ message VideoSendConfig {
   // required if rtx_ssrcs is used - Payload type for retransmitted packets.
   optional int32 rtx_payload_type = 4;
 
-  // required - Canonical end-point identifier.
-  optional string c_name = 5;
-
   // required - Encoder associated with the stream.
-  optional EncoderConfig encoder = 6;
+  optional EncoderConfig encoder = 5;
 }
 
 

webrtc/call/rtc_event_log_unittest.cc

@@ -20,6 +20,7 @@
 #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/random.h"
@@ -138,9 +139,6 @@ void VerifyReceiveStreamConfig(const rtclog::Event& event,
   else
     EXPECT_EQ(rtclog::VideoReceiveConfig::RTCP_REDUCEDSIZE,
               receiver_config.rtcp_mode());
-  ASSERT_TRUE(receiver_config.has_receiver_reference_time_report());
-  EXPECT_EQ(config.rtp.rtcp_xr.receiver_reference_time_report,
-            receiver_config.receiver_reference_time_report());
   ASSERT_TRUE(receiver_config.has_remb());
   EXPECT_EQ(config.rtp.remb, receiver_config.remb());
   // Check RTX map.
@@ -214,9 +212,6 @@ void VerifySendStreamConfig(const rtclog::Event& event,
     ASSERT_TRUE(sender_config.has_rtx_payload_type());
     EXPECT_EQ(config.rtp.rtx.payload_type, sender_config.rtx_payload_type());
   }
-  // Check CNAME.
-  ASSERT_TRUE(sender_config.has_c_name());
-  EXPECT_EQ(config.rtp.c_name, sender_config.c_name());
   // Check encoder.
   ASSERT_TRUE(sender_config.has_encoder());
   ASSERT_TRUE(sender_config.encoder().has_name());
@@ -230,7 +225,7 @@ void VerifySendStreamConfig(const rtclog::Event& event,
 void VerifyRtpEvent(const rtclog::Event& event,
                     bool incoming,
                     MediaType media_type,
-                    uint8_t* header,
+                    const uint8_t* header,
                     size_t header_size,
                     size_t total_size) {
   ASSERT_TRUE(IsValidBasicEvent(event));
@@ -252,7 +247,7 @@ void VerifyRtpEvent(const rtclog::Event& event,
 void VerifyRtcpEvent(const rtclog::Event& event,
                      bool incoming,
                      MediaType media_type,
-                     uint8_t* packet,
+                     const uint8_t* packet,
                      size_t total_size) {
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::RTCP_EVENT, event.type());
@@ -353,12 +348,19 @@ size_t GenerateRtpPacket(uint32_t extensions_bitvector,
   return header_size;
 }
 
-void GenerateRtcpPacket(uint8_t* packet,
+rtc::scoped_ptr<rtcp::RawPacket> GenerateRtcpPacket(test::Random* prng) {
-                        size_t packet_size,
+  rtcp::ReportBlock report_block;
-                        test::Random* prng) {
+  report_block.To(prng->Rand<uint32_t>());  // Remote SSRC.
-  for (size_t i = 0; i < packet_size; i++) {
+  report_block.WithFractionLost(prng->Rand(50));
-    packet[i] = prng->Rand<uint8_t>();
+
-  }
+  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,
@@ -375,7 +377,6 @@ void GenerateVideoReceiveConfig(uint32_t extensions_bitvector,
   // Add extensions and settings for RTCP.
   config->rtp.rtcp_mode =
       prng->Rand<bool>() ? RtcpMode::kCompound : RtcpMode::kReducedSize;
-  config->rtp.rtcp_xr.receiver_reference_time_report = prng->Rand<bool>();
   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;
@@ -402,8 +403,6 @@ void GenerateVideoSendConfig(uint32_t extensions_bitvector,
   // 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 a CNAME.
-  config->rtp.c_name = "some.user@some.host";
   // Add header extensions.
   for (unsigned i = 0; i < kNumExtensions; i++) {
     if (extensions_bitvector & (1u << i)) {
@@ -426,7 +425,7 @@ void LogSessionAndReadBack(size_t rtp_count,
   ASSERT_LE(playout_count, rtp_count);
   ASSERT_LE(bwe_loss_count, rtp_count);
   std::vector<rtc::Buffer> rtp_packets;
-  std::vector<rtc::Buffer> rtcp_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;
@@ -447,9 +446,7 @@ void LogSessionAndReadBack(size_t rtp_count,
   }
   // Create rtcp_count RTCP packets containing random data.
   for (size_t i = 0; i < rtcp_count; i++) {
-    size_t packet_size = prng.Rand(1000, 1100);
+    rtcp_packets.push_back(GenerateRtcpPacket(&prng));
-    rtcp_packets.push_back(rtc::Buffer(packet_size));
-    GenerateRtcpPacket(rtcp_packets[i].data(), packet_size, &prng);
   }
   // Create playout_count random SSRCs to use when logging AudioPlayout events.
   for (size_t i = 0; i < playout_count; i++) {
@@ -457,7 +454,8 @@ void LogSessionAndReadBack(size_t rtp_count,
   }
   // 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::pair<int32_t, uint8_t>(rand(), rand()));
+    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);
@@ -488,8 +486,8 @@ void LogSessionAndReadBack(size_t 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].data(),
+            rtcp_packets[rtcp_index - 1]->Buffer(),
-            rtcp_packets[rtcp_index - 1].size());
+            rtcp_packets[rtcp_index - 1]->Length());
         rtcp_index++;
       }
       if (i * playout_count >= playout_index * rtp_count) {
@@ -536,8 +534,8 @@ void LogSessionAndReadBack(size_t 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].data(),
+                      rtcp_packets[rtcp_index - 1]->Buffer(),
-                      rtcp_packets[rtcp_index - 1].size());
+                      rtcp_packets[rtcp_index - 1]->Length());
       event_index++;
       rtcp_index++;
     }
@@ -604,8 +602,8 @@ void DropOldEvents(uint32_t extensions_bitvector,
                    unsigned int random_seed) {
   rtc::Buffer old_rtp_packet;
   rtc::Buffer recent_rtp_packet;
-  rtc::Buffer old_rtcp_packet;
+  rtc::scoped_ptr<rtcp::RawPacket> old_rtcp_packet;
-  rtc::Buffer recent_rtcp_packet;
+  rtc::scoped_ptr<rtcp::RawPacket> recent_rtcp_packet;
 
   VideoReceiveStream::Config receiver_config(nullptr);
   VideoSendStream::Config sender_config(nullptr);
@@ -624,12 +622,8 @@ void DropOldEvents(uint32_t extensions_bitvector,
                         recent_rtp_packet.data(), packet_size, &prng);
 
   // Create two RTCP packets containing random data.
-  packet_size = prng.Rand(1000, 1100);
+  old_rtcp_packet = GenerateRtcpPacket(&prng);
-  old_rtcp_packet.SetSize(packet_size);
+  recent_rtcp_packet = GenerateRtcpPacket(&prng);
-  GenerateRtcpPacket(old_rtcp_packet.data(), packet_size, &prng);
-  packet_size = prng.Rand(1000, 1100);
-  recent_rtcp_packet.SetSize(packet_size);
-  GenerateRtcpPacket(recent_rtcp_packet.data(), packet_size, &prng);
 
   // Create configurations for the video streams.
   GenerateVideoReceiveConfig(extensions_bitvector, &receiver_config, &prng);
@@ -650,16 +644,16 @@ void DropOldEvents(uint32_t extensions_bitvector,
     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.data(),
+    log_dumper->LogRtcpPacket(true, MediaType::AUDIO, old_rtcp_packet->Buffer(),
-                              old_rtcp_packet.size());
+                              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.data(),
+                              recent_rtcp_packet->Buffer(),
-                              recent_rtcp_packet.size());
+                              recent_rtcp_packet->Length());
   }
 
   // Read the generated file from disk.
@@ -677,7 +671,7 @@ void DropOldEvents(uint32_t extensions_bitvector,
                  recent_rtp_packet.data(), recent_header_size,
                  recent_rtp_packet.size());
   VerifyRtcpEvent(parsed_stream.stream(4), false, MediaType::VIDEO,
-                  recent_rtcp_packet.data(), recent_rtcp_packet.size());
+                  recent_rtcp_packet->Buffer(), recent_rtcp_packet->Length());
 
   // Clean up temporary file - can be pretty slow.
   remove(temp_filename.c_str());