Skip logging RTCP messages of type SDES and APP.

webrtc/call/rtc_event_log_unittest.cc

 /*
  *  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 <stdio.h>
+#include <string.h>
 #include <string>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/checks.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_sender.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h"
 #include "webrtc/system_wrappers/interface/clock.h"
 #include "webrtc/test/test_suite.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/test/testsupport/gtest_disable.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
@@ skipping 97 matching lines @@
   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_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.
   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();
@@ skipping 53 matching lines @@
   // 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 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());
   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());
 }
 
@@ skipping 100 matching lines @@
       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] = rand();
   }
 
   return header_size;
 }
 
-void GenerateRtcpPacket(uint8_t* packet, size_t packet_size) {
-  for (size_t i = 0; i < packet_size; i++) {
-    packet[i] = rand();
+void GenerateRtcpPacket(rtc::Buffer* packet) {

[åsapersson, 2015/10/28 14:16:43]

To generate rtcp packets, the RtcpPacket class could perhaps be used directly.

For example, could something like this be used?

  ReportBlock rb;
  rb.To(kRemoteSsrc);
  rb.WithFractionLost(55);

  SenderReport sr;
  sr.From(kSenderSsrc);
  sr.WithNtpSec(123);
  sr.WithNtpFrac(456);
  sr.WithReportBlock(rb);
  rtc::scoped_ptr<RawPacket> packet(sr.Build());

[terelius, 2015/10/30 11:17:18]

Thanks for the suggestion; the new code is much cleaner.

+  class OnePacketTransport : public Transport, public NullRtpData {
+   public:
+    OnePacketTransport(rtc::Buffer* packet) { packet_ = packet; }
+
+    bool SendRtp(const uint8_t* /*data*/,
+                 size_t /*len*/,
+                 const PacketOptions& /*options*/) override {
+      return false;
+    }
+    bool SendRtcp(const uint8_t* data, size_t len) override {
+      packet_->AppendData(data, len);
+      return true;
+    }
+    int OnReceivedPayloadData(const uint8_t* /*payload_data*/,
+                              const size_t /*payload_size*/,
+                              const WebRtcRTPHeader* /*rtp_header*/) override {
+      return 0;
+    }
+    rtc::Buffer* packet_;
+  };
+
+  packet->EnsureCapacity(IP_PACKET_SIZE);
+  packet->SetSize(0);
+  OnePacketTransport transport(packet);
+  SimulatedClock clock(1335900000);
+  rtc::scoped_ptr<ReceiveStatistics> receive_statistics(
+      ReceiveStatistics::Create(&clock));
+  RTCPSender::FeedbackState feedback_state;
+  RTCPSender rtcp_sender(false,                     // audio
+                         &clock,                    // clock
+                         receive_statistics.get(),  // Used to generate RR
+                         nullptr,  // packet_type_counter_observer
+                         &transport);
+  rtcp_sender.SetSSRC(rand());        // kSenderSsrc
+  rtcp_sender.SetRemoteSSRC(rand());  // kRemoteSsrc
+
+  // Insert packets in receive statistics
+  for (int i = 0; i < 5; i++) {
+    RTPHeader header;
+    header.ssrc = rand();
+    header.sequenceNumber = rand();
+    header.timestamp = rand();
+    header.headerLength = 12;
+    size_t kPacketLength = 100 + rand() % 100;
+    receive_statistics->IncomingPacket(header, kPacketLength, false);
   }
+
+  rtcp_sender.SetRTCPStatus(RtcpMode::kCompound);
+  rtcp_sender.SendRTCP(feedback_state, kRtcpRr);
+
+  // assert(transport.packet.size() <= packet_size);
+  // packet_size = transport.packet.size();
+  // memcpy(packet, transport.packet.data(), packet_size);
+  // return packet_size;

[stefan-webrtc, 2015/10/28 13:37:12]

Should this code be removed?

[terelius, 2015/10/30 11:17:18]

Yes. Done.

 }
 
 void GenerateVideoReceiveConfig(uint32_t extensions_bitvector,
                                 VideoReceiveStream::Config* config) {
   // Create a map from a payload type to an encoder name.
   VideoReceiveStream::Decoder decoder;
   decoder.payload_type = rand();
   decoder.payload_name = (rand() % 2 ? "VP8" : "H264");
   config->decoders.push_back(decoder);
   // Add SSRCs for the stream.
   config->rtp.remote_ssrc = rand();
   config->rtp.local_ssrc = rand();
   // Add extensions and settings for RTCP.
   config->rtp.rtcp_mode =
       rand() % 2 ? RtcpMode::kCompound : RtcpMode::kReducedSize;
-  config->rtp.rtcp_xr.receiver_reference_time_report = (rand() % 2 == 1);
   config->rtp.remb = (rand() % 2 == 1);
   // 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 = rand();
   rtx_pair.payload_type = rand();
   config->rtp.rtx.insert(std::make_pair(rand(), 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], rand()));
     }
   }
 }
 
 void GenerateVideoSendConfig(uint32_t extensions_bitvector,
                              VideoSendStream::Config* config) {
   // Create a map from a payload type to an encoder name.
   config->encoder_settings.payload_type = rand();
   config->encoder_settings.payload_name = (rand() % 2 ? "VP8" : "H264");
   // Add SSRCs for the stream.
   config->rtp.ssrcs.push_back(rand());
   // Add a map from a payload type to new ssrcs and a new payload type for RTX.
   config->rtp.rtx.ssrcs.push_back(rand());
   config->rtp.rtx.payload_type = rand();
-  // 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)) {
       config->rtp.extensions.push_back(
           RtpExtension(kExtensionNames[i], rand()));
     }
   }
 }
 
 // Test for the RtcEventLog class. Dumps some RTP packets and other events
@@ skipping 19 matching lines @@
   // Create rtp_count RTP packets containing random data.
   for (size_t i = 0; i < rtp_count; i++) {
     size_t packet_size = 1000 + rand() % 64;
     rtp_packets.push_back(rtc::Buffer(packet_size));
     size_t header_size = GenerateRtpPacket(extensions_bitvector, csrcs_count,
                                            rtp_packets[i].data(), packet_size);
     rtp_header_sizes.push_back(header_size);
   }
   // Create rtcp_count RTCP packets containing random data.
   for (size_t i = 0; i < rtcp_count; i++) {
-    size_t packet_size = 1000 + rand() % 64;
-    rtcp_packets.push_back(rtc::Buffer(packet_size));
-    GenerateRtcpPacket(rtcp_packets[i].data(), packet_size);
+    rtcp_packets.push_back(rtc::Buffer());
+    GenerateRtcpPacket(&(rtcp_packets[i]));
   }
   // Create playout_count random SSRCs to use when logging AudioPlayout events.
   for (size_t i = 0; i < playout_count; i++) {
     playout_ssrcs.push_back(static_cast<uint32_t>(rand()));
   }
   // Create configurations for the video streams.
   GenerateVideoReceiveConfig(extensions_bitvector, &receiver_config);
   GenerateVideoSendConfig(extensions_bitvector, &sender_config);
   const int config_count = 2;
 
@@ skipping 129 matching lines @@
   size_t packet_size = 1000 + rand() % 64;
   old_rtp_packet.SetSize(packet_size);
   GenerateRtpPacket(extensions_bitvector, csrcs_count, old_rtp_packet.data(),
                     packet_size);
   packet_size = 1000 + rand() % 64;
   recent_rtp_packet.SetSize(packet_size);
   size_t recent_header_size = GenerateRtpPacket(
       extensions_bitvector, csrcs_count, recent_rtp_packet.data(), packet_size);
 
   // Create two RTCP packets containing random data.
-  packet_size = 1000 + rand() % 64;
-  old_rtcp_packet.SetSize(packet_size);
-  GenerateRtcpPacket(old_rtcp_packet.data(), packet_size);
-  packet_size = 1000 + rand() % 64;
-  recent_rtcp_packet.SetSize(packet_size);
-  GenerateRtcpPacket(recent_rtcp_packet.data(), packet_size);
+  GenerateRtcpPacket(&old_rtcp_packet);
+  GenerateRtcpPacket(&recent_rtcp_packet);
 
   // Create configurations for the video streams.
   GenerateVideoReceiveConfig(extensions_bitvector, &receiver_config);
   GenerateVideoSendConfig(extensions_bitvector, &sender_config);
 
   // 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();
@@ skipping 44 matching lines @@
   // 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