Add test which verifies that the RTP header extensions are set correctly for FEC packets.

webrtc/video/video_send_stream_tests.cc

 /*
  *  Copyright (c) 2013 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 <algorithm>  // max
@@ skipping 109 matching lines @@
     void PerformTest() override {
       EXPECT_EQ(kEventSignaled, Wait())
           << "Timed out while waiting for RTCP with CNAME.";
     }
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
-  static const uint8_t kAbsSendTimeExtensionId = 13;
   class AbsoluteSendTimeObserver : public test::SendTest {
    public:
     AbsoluteSendTimeObserver() : SendTest(kDefaultTimeoutMs) {
       EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(
-          kRtpExtensionAbsoluteSendTime, kAbsSendTimeExtensionId));
+          kRtpExtensionAbsoluteSendTime, test::kAbsSendTimeExtensionId));
     }
 
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
       EXPECT_FALSE(header.extension.hasTransmissionTimeOffset);
       EXPECT_TRUE(header.extension.hasAbsoluteSendTime);
       EXPECT_EQ(header.extension.transmissionTimeOffset, 0);
       EXPECT_GT(header.extension.absoluteSendTime, 0u);
       observation_complete_->Set();
 
       return SEND_PACKET;
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       send_config->rtp.extensions.clear();
-      send_config->rtp.extensions.push_back(
-          RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId));
+      send_config->rtp.extensions.push_back(RtpExtension(
+          RtpExtension::kAbsSendTime, test::kAbsSendTimeExtensionId));
     }
 
     void PerformTest() override {
       EXPECT_EQ(kEventSignaled, Wait())
           << "Timed out while waiting for single RTP packet.";
     }
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
@@ skipping 136 matching lines @@
       return true;
     }
 
     RtcpStatistics stats_;
   };
 
   rtc::scoped_ptr<LossyStatistician> lossy_stats_;
   StatisticianMap stats_map_;
 };
 
-TEST_F(VideoSendStreamTest, SupportsFec) {
-  class FecObserver : public test::SendTest {
-   public:
-    FecObserver()
-        : SendTest(kDefaultTimeoutMs),
-          send_count_(0),
-          received_media_(false),
-          received_fec_(false) {
+class FecObserver : public test::SendTest {
+ public:
+  explicit FecObserver(bool header_extensions_enabled)
+      : SendTest(VideoSendStreamTest::kDefaultTimeoutMs),
+        send_count_(0),
+        received_media_(false),
+        received_fec_(false),
+        header_extensions_enabled_(header_extensions_enabled) {}
+
+ private:
+  Action OnSendRtp(const uint8_t* packet, size_t length) override {
+    RTPHeader header;
+    EXPECT_TRUE(parser_->Parse(packet, length, &header));
+
+    // Send lossy receive reports to trigger FEC enabling.
+    if (send_count_++ % 2 != 0) {
+      // Receive statistics reporting having lost 50% of the packets.
+      FakeReceiveStatistics lossy_receive_stats(
+          VideoSendStreamTest::kSendSsrcs[0], header.sequenceNumber,
+          send_count_ / 2, 127);
+      RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(),
+                             &lossy_receive_stats, nullptr,
+                             transport_adapter_.get());
+
+      rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
+      rtcp_sender.SetRemoteSSRC(VideoSendStreamTest::kSendSsrcs[0]);
+
+      RTCPSender::FeedbackState feedback_state;
+
+      EXPECT_EQ(0, rtcp_sender.SendRTCP(feedback_state, kRtcpRr));
     }
 
-   private:
-    Action OnSendRtp(const uint8_t* packet, size_t length) override {
-      RTPHeader header;
-      EXPECT_TRUE(parser_->Parse(packet, length, &header));
-
-      // Send lossy receive reports to trigger FEC enabling.
-      if (send_count_++ % 2 != 0) {
-        // Receive statistics reporting having lost 50% of the packets.
-        FakeReceiveStatistics lossy_receive_stats(
-            kSendSsrcs[0], header.sequenceNumber, send_count_ / 2, 127);
-        RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(),
-                               &lossy_receive_stats, nullptr,
-                               transport_adapter_.get());
-
-        rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
-        rtcp_sender.SetRemoteSSRC(kSendSsrcs[0]);
-
-        RTCPSender::FeedbackState feedback_state;
-
-        EXPECT_EQ(0, rtcp_sender.SendRTCP(feedback_state, kRtcpRr));
-      }
-
-      int encapsulated_payload_type = -1;
-      if (header.payloadType == kRedPayloadType) {
-        encapsulated_payload_type =
-            static_cast<int>(packet[header.headerLength]);
-        if (encapsulated_payload_type != kFakeSendPayloadType)
-          EXPECT_EQ(kUlpfecPayloadType, encapsulated_payload_type);
-      } else {
-        EXPECT_EQ(kFakeSendPayloadType, header.payloadType);
-      }
-
-      if (encapsulated_payload_type != -1) {
-        if (encapsulated_payload_type == kUlpfecPayloadType) {
-          received_fec_ = true;
-        } else {
-          received_media_ = true;
-        }
-      }
-
-      if (received_media_ && received_fec_)
-        observation_complete_->Set();
-
-      return SEND_PACKET;
+    int encapsulated_payload_type = -1;
+    if (header.payloadType == VideoSendStreamTest::kRedPayloadType) {
+      encapsulated_payload_type = static_cast<int>(packet[header.headerLength]);
+      if (encapsulated_payload_type !=
+          VideoSendStreamTest::kFakeSendPayloadType)
+        EXPECT_EQ(VideoSendStreamTest::kUlpfecPayloadType,
+                  encapsulated_payload_type);
+    } else {
+      EXPECT_EQ(VideoSendStreamTest::kFakeSendPayloadType, header.payloadType);
     }
 
-    void ModifyConfigs(VideoSendStream::Config* send_config,
-                       std::vector<VideoReceiveStream::Config>* receive_configs,
-                       VideoEncoderConfig* encoder_config) override {
-      transport_adapter_.reset(
-          new internal::TransportAdapter(send_config->send_transport));
-      transport_adapter_->Enable();
-      send_config->rtp.fec.red_payload_type = kRedPayloadType;
-      send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
+    if (header_extensions_enabled_) {
+      EXPECT_TRUE(header.extension.hasAbsoluteSendTime);
+      uint32_t kHalf24BitsSpace = 0xFFFFFF / 2;
+      if (header.extension.absoluteSendTime <= kHalf24BitsSpace &&
+          prev_header_.extension.absoluteSendTime > kHalf24BitsSpace) {
+        // 24 bits wrap.
+        EXPECT_GT(prev_header_.extension.absoluteSendTime,
+                  header.extension.absoluteSendTime);
+      } else {
+        EXPECT_GE(header.extension.absoluteSendTime,
+                  prev_header_.extension.absoluteSendTime);
+      }
+      EXPECT_TRUE(header.extension.hasTransportSequenceNumber);
+      uint16_t seq_num_diff = header.extension.transportSequenceNumber -
+                              prev_header_.extension.transportSequenceNumber;
+      EXPECT_EQ(1, seq_num_diff);
     }
 
-    void PerformTest() override {
-      EXPECT_TRUE(Wait()) << "Timed out waiting for FEC and media packets.";
+    if (encapsulated_payload_type != -1) {
+      if (encapsulated_payload_type ==
+          VideoSendStreamTest::kUlpfecPayloadType) {
+        received_fec_ = true;
+      } else {
+        received_media_ = true;
+      }
     }
 
-    rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
-    int send_count_;
-    bool received_media_;
-    bool received_fec_;
-  } test;
+    if (received_media_ && received_fec_ && send_count_ > 100)
+      observation_complete_->Set();
+
+    prev_header_ = header;
+
+    return SEND_PACKET;
+  }
+
+  void ModifyConfigs(VideoSendStream::Config* send_config,
+                     std::vector<VideoReceiveStream::Config>* receive_configs,
+                     VideoEncoderConfig* encoder_config) override {
+    transport_adapter_.reset(
+        new internal::TransportAdapter(send_config->send_transport));
+    transport_adapter_->Enable();
+    send_config->rtp.fec.red_payload_type =
+        VideoSendStreamTest::kRedPayloadType;
+    send_config->rtp.fec.ulpfec_payload_type =
+        VideoSendStreamTest::kUlpfecPayloadType;
+    if (header_extensions_enabled_) {
+      send_config->rtp.extensions.push_back(RtpExtension(
+          RtpExtension::kAbsSendTime, test::kAbsSendTimeExtensionId));
+      send_config->rtp.extensions.push_back(
+          RtpExtension(RtpExtension::kTransportSequenceNumber,
+                       test::kTransportSequenceNumberExtensionId));
+    }
+  }
+
+  void PerformTest() override {
+    EXPECT_TRUE(Wait()) << "Timed out waiting for FEC and media packets.";
+  }
+
+  rtc::scoped_ptr<internal::TransportAdapter> transport_adapter_;
+  int send_count_;
+  bool received_media_;
+  bool received_fec_;
+  bool header_extensions_enabled_;
+  RTPHeader prev_header_;
+};
+
+TEST_F(VideoSendStreamTest, SupportsFecWithExtensions) {
+  FecObserver test(true);
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
+
+TEST_F(VideoSendStreamTest, SupportsFecWithoutExtensions) {
+  FecObserver test(false);
+
+  RunBaseTest(&test, FakeNetworkPipe::Config());
+}
 
 void VideoSendStreamTest::TestNackRetransmission(
     uint32_t retransmit_ssrc,
     uint8_t retransmit_payload_type) {
   class NackObserver : public test::SendTest {
    public:
     explicit NackObserver(uint32_t retransmit_ssrc,
                           uint8_t retransmit_payload_type)
         : SendTest(kDefaultTimeoutMs),
           send_count_(0),
@@ skipping 1768 matching lines @@
         EXPECT_GT(vp9_header.num_ref_pics, 0u);
         observation_complete_->Set();
       }
     }
   } test;
 
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 }  // namespace webrtc