Use RtpPacketToSend in RtpSenderAudio

webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
 #include <memory>
 #include <vector>
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/rate_limiter.h"
 #include "webrtc/call/mock/mock_rtc_event_log.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_cvo.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.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/modules/rtp_rtcp/source/rtp_sender.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_sender_video.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 #include "webrtc/system_wrappers/include/stl_util.h"
 #include "webrtc/test/mock_transport.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 
 namespace {
@@ skipping 11 matching lines @@
 const uint16_t kTransportSequenceNumber = 0xaabbu;
 const uint8_t kAudioLevelExtensionId = 9;
 const int kAudioPayload = 103;
 const uint64_t kStartTime = 123456789;
 const size_t kMaxPaddingSize = 224u;
 const int kVideoRotationExtensionId = 5;
 const VideoRotation kRotation = kVideoRotation_270;
 const size_t kGenericHeaderLength = 1;
 const uint8_t kPayloadData[] = {47, 11, 32, 93, 89};
 
-using testing::_;
+using ::testing::_;
+using ::testing::ElementsAreArray;
 
 const uint8_t* GetPayloadData(const RTPHeader& rtp_header,
                               const uint8_t* packet) {
   return packet + rtp_header.headerLength;
 }
 
 size_t GetPayloadDataLength(const RTPHeader& rtp_header,
                             const size_t packet_length) {
   return packet_length - rtp_header.headerLength - rtp_header.paddingLength;
 }
@@ skipping 298 matching lines @@
 
   EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension());
   EXPECT_EQ(
       RtpUtility::Word32Align(kRtpOneByteHeaderLength + kVideoRotationLength),
       rtp_sender_->RtpHeaderExtensionLength());
   EXPECT_EQ(
       0, rtp_sender_->DeregisterRtpHeaderExtension(kRtpExtensionVideoRotation));
   EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionLength());
 }
 
+TEST_F(RtpSenderTestWithoutPacer, AllocatePacketSetCsrc) {
+  // Configure rtp_sender with an extension and csrc.
+  ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
+                   kRtpExtensionTransmissionTimeOffset,
+                   kTransmissionTimeOffsetExtensionId));
+  std::vector<uint32_t> csrcs;
+  csrcs.push_back(0x23456789);
+  rtp_sender_->SetCsrcs(csrcs);
+
+  auto packet = rtp_sender_->AllocatePacket();
+
+  ASSERT_TRUE(packet);
+  EXPECT_EQ(rtp_sender_->SSRC(), packet->Ssrc());
+  EXPECT_THAT(packet->Csrcs(), ElementsAreArray(csrcs));
+  EXPECT_TRUE(packet->HasExtension<TransmissionOffset>());
+}
+
+TEST_F(RtpSenderTestWithoutPacer, AllocatePacketReserveExtensions) {
+  // Configure rtp_sender with extensions.
+  ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
+                   kRtpExtensionTransmissionTimeOffset,
+                   kTransmissionTimeOffsetExtensionId));
+  ASSERT_EQ(
+      0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
+                                                 kAbsoluteSendTimeExtensionId));
+  ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
+                                                       kAudioLevelExtensionId));
+  ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
+                   kRtpExtensionTransportSequenceNumber,
+                   kTransportSequenceNumberExtensionId));
+
+  auto packet = rtp_sender_->AllocatePacket();
+
+  ASSERT_TRUE(packet);
+  // Preallocate extensions RtpSender set itself.
+  EXPECT_TRUE(packet->HasExtension<TransmissionOffset>());
+  EXPECT_TRUE(packet->HasExtension<AbsoluteSendTime>());
+  EXPECT_TRUE(packet->HasExtension<TransportSequenceNumber>());
+  // Do not allocate extensions RtpSenderAudio/RtpSenderVideo set.
+  EXPECT_FALSE(packet->HasExtension<AudioLevel>());
+}
+
+TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberAdvanceSequnceNumber) {
+  const uint16_t sequence_number = rtp_sender_->SequenceNumber();
+  auto packet = rtp_sender_->AllocatePacket();
+  ASSERT_TRUE(packet);
+
+  EXPECT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
+
+  EXPECT_EQ(sequence_number, packet->SequenceNumber());
+  EXPECT_EQ(sequence_number + 1, rtp_sender_->SequenceNumber());
+}
+
+TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberFailsOnNotSending) {
+  auto packet = rtp_sender_->AllocatePacket();
+  ASSERT_TRUE(packet);
+
+  rtp_sender_->SetSendingMediaStatus(false);
+  EXPECT_FALSE(rtp_sender_->AssignSequenceNumber(packet.get()));
+}
+
+TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberMayAllowPadding) {
+  constexpr size_t kPaddingSize = 100;
+  auto packet = rtp_sender_->AllocatePacket();
+  ASSERT_TRUE(packet);
+
+  ASSERT_FALSE(rtp_sender_->SendPadData(kPaddingSize, false, 0, 0, -1));
+  packet->SetMarker(false);
+  ASSERT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
+  // Packet without marker bit doesn't allow padding.
+  EXPECT_FALSE(rtp_sender_->SendPadData(kPaddingSize, false, 0, 0, -1));
+
+  packet->SetMarker(true);
+  ASSERT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
+  // Packet with marker bit allows send padding.
+  EXPECT_TRUE(rtp_sender_->SendPadData(kPaddingSize, false, 0, 0, -1));
+}
+
+TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberSetPaddingTimestamps) {
+  constexpr size_t kPaddingSize = 100;
+  auto packet = rtp_sender_->AllocatePacket();
+  ASSERT_TRUE(packet);
+  packet->SetMarker(true);
+  packet->SetTimestamp(kTimestamp);
+
+  ASSERT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
+  ASSERT_TRUE(rtp_sender_->SendPadData(kPaddingSize, false, 0, 0, -1));
+
+  ASSERT_EQ(1u, transport_.sent_packets_.size());
+  // Parse the padding packet and verify it's timestamp match.
+  RtpPacketToSend padding_packet(nullptr);
+  ASSERT_TRUE(padding_packet.Parse(transport_.sent_packets_[0]->data(),
+                                   transport_.sent_packets_[0]->size()));
+  EXPECT_EQ(kTimestamp, padding_packet.Timestamp());
+}
+
 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacket) {
   size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader(
       packet_, kPayload, kMarkerBit, kTimestamp, 0));
   ASSERT_EQ(kRtpHeaderSize, length);
 
   // Verify
   webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
   webrtc::RTPHeader rtp_header;
 
   const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, nullptr);
@@ skipping 1300 matching lines @@
       reinterpret_cast<uint8_t*>(transport_.sent_packets_[0]->data()),
       transport_.sent_packets_[0]->size(), true, &map, kSeqNum, hdr.rotation);
 
   // Verify that this packet does have CVO byte.
   VerifyCVOPacket(
       reinterpret_cast<uint8_t*>(transport_.sent_packets_[1]->data()),
       transport_.sent_packets_[1]->size(), true, &map, kSeqNum + 1,
       hdr.rotation);
 }
 }  // namespace webrtc