Generate random rtp packets with RtpPacketToSend instead of RtpSender

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 <map>
 #include <memory>
 #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/rate_limiter.h"
 #include "webrtc/call.h"
 #include "webrtc/call/rtc_event_log.h"
 #include "webrtc/call/rtc_event_log_parser.h"
 #include "webrtc/call/rtc_event_log_unittest_helper.h"
 #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_sender.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.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
@@ skipping 57 matching lines @@
   }
   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.
  */
-size_t GenerateRtpPacket(uint32_t extensions_bitvector,
-                         uint32_t csrcs_count,
-                         uint8_t* packet,
-                         size_t packet_size,
-                         Random* prng) {
+RtpPacketToSend GenerateRtpPacket(const RtpHeaderExtensionMap* extensions,
+                                  uint32_t csrcs_count,
+                                  size_t packet_size,
+                                  Random* prng) {
   RTC_CHECK_GE(packet_size, 16 + 4 * csrcs_count + 4 * kNumExtensions);
-  Clock* clock = Clock::GetRealTimeClock();
-  RateLimiter retranmission_rate_limiter(clock, 1000);
-
-  RTPSender rtp_sender(false,    // bool audio
-                       clock,    // Clock* clock
-                       nullptr,  // Transport*
-                       nullptr,  // PacedSender*
-                       nullptr,  // PacketRouter*
-                       nullptr,  // SendTimeObserver*
-                       nullptr,  // BitrateStatisticsObserver*
-                       nullptr,  // FrameCountObserver*
-                       nullptr,  // SendSideDelayObserver*
-                       nullptr,  // RtcEventLog*
-                       nullptr,  // SendPacketObserver*
-                       &retranmission_rate_limiter);
 
   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);
-    }
+  RtpPacketToSend rtp_packet(extensions, packet_size);
+  rtp_packet.SetPayloadType(prng->Rand(127));
+  rtp_packet.SetMarker(prng->Rand<bool>());
+  rtp_packet.SetSequenceNumber(prng->Rand<uint16_t>());
+  rtp_packet.SetSsrc(prng->Rand<uint32_t>());
+  rtp_packet.SetTimestamp(prng->Rand<uint32_t>());
+  rtp_packet.SetCsrcs(csrcs);
+
+  rtp_packet.SetExtension<TransmissionOffset>(prng->Rand(0x00ffffff));

[terelius, 2016/08/09 11:43:00]

These functions set the extension if and only if that extension type has been
configured in the RtpHeaderExtensionMap?

[danilchap, 2016/08/09 12:49:23]

In this case (calling functions before setting payload) - yes.
Those functions also return false when extension is not configured in the
RtpHeaderExtensionMap or the map is absent (nullptr).

[terelius, 2016/08/09 13:31:32]

So you can only set new extensions before payload, and only if they have been
configured in RtpHeaderExtensionMap. Is that correct?

+  rtp_packet.SetExtension<AudioLevel>(prng->Rand<bool>(), prng->Rand(127));
+  rtp_packet.SetExtension<AbsoluteSendTime>(prng->Rand<int32_t>());
+  rtp_packet.SetExtension<VideoOrientation>(prng->Rand(2));
+  rtp_packet.SetExtension<TransportSequenceNumber>(prng->Rand<uint16_t>());
+
+  size_t payload_size = packet_size - rtp_packet.headers_size();
+  uint8_t* payload = rtp_packet.AllocatePayload(payload_size);
+  for (size_t i = 0; i < payload_size; i++) {
+    payload[i] = prng->Rand<uint8_t>();
   }
-
-  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>();
-
-  size_t header_size = rtp_sender.BuildRtpHeader(
-      packet, payload_type, marker_bit, capture_timestamp, capture_time_ms);
-  for (size_t i = header_size; i < packet_size; i++) {
-    packet[i] = prng->Rand<uint8_t>();
-  }
-
-  return header_size;
+  return rtp_packet;
 }
 
 rtc::Buffer 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.WithNtp(
@@ skipping 58 matching lines @@
 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<RtpPacketToSend> rtp_packets;
   std::vector<rtc::Buffer> 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);
 
+  // Initialize rtp header extensions to be used in generated rtp packets.
+  RtpHeaderExtensionMap extensions;
+  for (unsigned i = 0; i < kNumExtensions; i++) {
+    if (extensions_bitvector & (1u << i)) {
+      extensions.Register(kExtensionTypes[i], i + 1);
+    }
+  }
   // Create rtp_count RTP packets containing random data.
   for (size_t i = 0; i < rtp_count; i++) {
     size_t packet_size = prng.Rand(1000, 1100);
-    rtp_packets.push_back(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);
+    rtp_packets.push_back(
+        GenerateRtpPacket(&extensions, csrcs_count, packet_size, &prng));
   }
   // Create rtcp_count RTCP packets containing random data.
   for (size_t i = 0; i < rtcp_count; i++) {
     rtcp_packets.push_back(GenerateRtcpPacket(&prng));
   }
   // Create playout_count random SSRCs to use when logging AudioPlayout events.
   for (size_t i = 0; i < playout_count; i++) {
     playout_ssrcs.push_back(prng.Rand<uint32_t>());
   }
   // Create bwe_loss_count random bitrate updates for BwePacketLoss.
@@ skipping 82 matching lines @@
   RtcEventLogTestHelper::VerifySendStreamConfig(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,
         (i % 3 == 0) ? MediaType::AUDIO : MediaType::VIDEO,
-        rtp_packets[i - 1].data(), rtp_header_sizes[i - 1],
+        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_index % 3 == 0 ? MediaType::AUDIO : MediaType::VIDEO,
           rtcp_packets[rtcp_index - 1].data(),
           rtcp_packets[rtcp_index - 1].size());
       event_index++;
@@ skipping 49 matching lines @@
                             extensions * 3 + csrcs_count + 1);  // Random seed.
     }
   }
 }
 
 TEST(RtcEventLogTest, LogEventAndReadBack) {
   Random prng(987654321);
 
   // Create one RTP and one RTCP packet containing random data.
   size_t packet_size = prng.Rand(1000, 1100);
-  rtc::Buffer rtp_packet(packet_size);
-  size_t header_size =
-      GenerateRtpPacket(0, 0, rtp_packet.data(), packet_size, &prng);
+  RtpPacketToSend rtp_packet =
+      GenerateRtpPacket(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
   // 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();
 
   // Add RTP, start logging, add RTCP and then stop logging
   SimulatedClock fake_clock(prng.Rand<uint32_t>());
@@ skipping 15 matching lines @@
   // Read the generated file from disk.
   ParsedRtcEventLog parsed_log;
   ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
 
   // Verify that what we read back from the event log is the same as
   // what we wrote down.
   EXPECT_EQ(4u, parsed_log.GetNumberOfEvents());
 
   RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0);
 
-  RtcEventLogTestHelper::VerifyRtpEvent(parsed_log, 1, kIncomingPacket,
-                                        MediaType::VIDEO, rtp_packet.data(),
-                                        header_size, rtp_packet.size());
+  RtcEventLogTestHelper::VerifyRtpEvent(
+      parsed_log, 1, kIncomingPacket, MediaType::VIDEO, rtp_packet.data(),
+      rtp_packet.headers_size(), rtp_packet.size());
 
   RtcEventLogTestHelper::VerifyRtcpEvent(parsed_log, 2, kOutgoingPacket,
                                          MediaType::VIDEO, rtcp_packet.data(),
                                          rtcp_packet.size());
 
   RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 3);
 
   // Clean up temporary file - can be pretty slow.
   remove(temp_filename.c_str());
 }
 }  // namespace webrtc
 
 #endif  // ENABLE_RTC_EVENT_LOG