Only store sequence numbers for media stream in FlexFEC end-to-end test.

webrtc/video/end_to_end_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>
 #include <list>
 #include <map>
 #include <memory>
 #include <sstream>
 #include <string>
 #include <vector>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/event.h"
 #include "webrtc/base/file.h"
 #include "webrtc/base/optional.h"
+#include "webrtc/base/random.h"
 #include "webrtc/base/rate_limiter.h"
 #include "webrtc/call/call.h"
 #include "webrtc/common_video/include/frame_callback.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
 #include "webrtc/media/base/fakevideorenderer.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.h"
@@ skipping 669 matching lines @@
   } test;
 
   RunBaseTest(&test);
 }
 
 TEST_P(EndToEndTest, CanReceiveFlexfec) {
   class FlexfecRenderObserver : public test::EndToEndTest,
                                 public rtc::VideoSinkInterface<VideoFrame> {
    public:
     FlexfecRenderObserver()
-        : EndToEndTest(kDefaultTimeoutMs), state_(kFirstPacket) {}
+        : EndToEndTest(kDefaultTimeoutMs), random_(0xcafef00d1) {}
 
     size_t GetNumFlexfecStreams() const override { return 1; }
 
    private:
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       rtc::CritScope lock(&crit_);
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
       uint8_t payload_type = header.payloadType;
       if (payload_type != kFakeVideoSendPayloadType) {
         EXPECT_EQ(kFlexfecPayloadType, payload_type);
       }
 
-      auto seq_num_it = protected_sequence_numbers_.find(header.sequenceNumber);
-      if (seq_num_it != protected_sequence_numbers_.end()) {
-        // Retransmitted packet, should not count.
-        protected_sequence_numbers_.erase(seq_num_it);
-        auto ts_it = protected_timestamps_.find(header.timestamp);
-        EXPECT_NE(ts_it, protected_timestamps_.end());
-        protected_timestamps_.erase(ts_it);
-        return SEND_PACKET;
+      // Is this a retransmitted media packet? From the perspective of FEC, this
+      // packet is then no longer dropped, so remove it from the list of
+      // dropped packets.
+      if (payload_type == kFakeVideoSendPayloadType) {
+        auto seq_num_it = dropped_sequence_numbers_.find(header.sequenceNumber);
+        if (seq_num_it != dropped_sequence_numbers_.end()) {
+          dropped_sequence_numbers_.erase(seq_num_it);
+          auto ts_it = dropped_timestamps_.find(header.timestamp);
+          EXPECT_NE(ts_it, dropped_timestamps_.end());
+          dropped_timestamps_.erase(ts_it);
+
+          return SEND_PACKET;
+        }
       }
 
-      switch (state_) {
-        case kFirstPacket:
-          state_ = kDropEveryOtherPacketUntilFlexfec;
-          break;
-        case kDropEveryOtherPacketUntilFlexfec:
-          if (payload_type == kFlexfecPayloadType) {
-            state_ = kDropNextMediaPacket;
-            return SEND_PACKET;
-          }
-          if (header.sequenceNumber % 2 == 0)
-            return DROP_PACKET;
-          break;
-        case kDropNextMediaPacket:
-          if (payload_type == kFakeVideoSendPayloadType) {
-            protected_sequence_numbers_.insert(header.sequenceNumber);
-            protected_timestamps_.insert(header.timestamp);
-            state_ = kDropEveryOtherPacketUntilFlexfec;
-            return DROP_PACKET;
-          }
-          break;
+      // Simulate 5% packet loss. Record what media packets, and corresponding
+      // timestamps, that were dropped.
+      if (random_.Rand(1, 100) <= 5) {
+        if (payload_type == kFakeVideoSendPayloadType) {
+          dropped_sequence_numbers_.insert(header.sequenceNumber);
+          dropped_timestamps_.insert(header.timestamp);
+        }
+
+        return DROP_PACKET;
       }
 
       return SEND_PACKET;
     }
 
     void OnFrame(const VideoFrame& video_frame) override {
       rtc::CritScope lock(&crit_);
       // Rendering frame with timestamp of packet that was dropped -> FEC
       // protection worked.
-      auto it = protected_timestamps_.find(video_frame.timestamp());
-      if (it != protected_timestamps_.end())
+      auto it = dropped_timestamps_.find(video_frame.timestamp());
+      if (it != dropped_timestamps_.end())
         observation_complete_.Set();
     }
 
-    enum {
-      kFirstPacket,
-      kDropEveryOtherPacketUntilFlexfec,
-      kDropNextMediaPacket,
-    } state_;
-
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       (*receive_configs)[0].renderer = this;
     }
 
     void PerformTest() override {
       EXPECT_TRUE(Wait())
           << "Timed out waiting for dropped frames to be rendered.";
     }
 
     rtc::CriticalSection crit_;
-    std::set<uint32_t> protected_sequence_numbers_ GUARDED_BY(crit_);
+    std::set<uint32_t> dropped_sequence_numbers_ GUARDED_BY(crit_);
     // Since several packets can have the same timestamp a multiset is used
     // instead of a set.
-    std::multiset<uint32_t> protected_timestamps_ GUARDED_BY(crit_);
+    std::multiset<uint32_t> dropped_timestamps_ GUARDED_BY(crit_);
+    Random random_;
   } test;
 
   RunBaseTest(&test);
 }
 
 TEST_P(EndToEndTest, ReceivedUlpfecPacketsNotNacked) {
   class UlpfecNackObserver : public test::EndToEndTest {
    public:
     UlpfecNackObserver()
         : EndToEndTest(kDefaultTimeoutMs),
@@ skipping 3267 matching lines @@
     std::unique_ptr<VideoEncoder> encoder_;
     std::unique_ptr<VideoDecoder> decoder_;
     rtc::CriticalSection crit_;
     int recorded_frames_ GUARDED_BY(crit_);
   } test(this);
 
   RunBaseTest(&test);
 }
 
 }  // namespace webrtc