Ignore padding-only RTX packets in 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>
@@ skipping 684 matching lines @@
     bool has_last_sequence_number_;
     uint16_t last_sequence_number_;
   } test;
 
   RunBaseTest(&test);
 }
 
 // This test drops second RTP packet with a marker bit set, makes sure it's
 // retransmitted and renders. Retransmission SSRCs are also checked.
 void EndToEndTest::DecodesRetransmittedFrame(bool enable_rtx, bool enable_red) {
-  // Must be set high enough to allow the bitrate probing to finish.
-  static const int kMinProbePackets = 100;
-  static const int kDroppedFrameNumber = kMinProbePackets + 1;
+  static const int kDroppedFrameNumber = 10;
   class RetransmissionObserver : public test::EndToEndTest,
                                  public I420FrameCallback {
    public:
     RetransmissionObserver(bool enable_rtx, bool enable_red)
         : EndToEndTest(kDefaultTimeoutMs),
           payload_type_(GetPayloadType(false, enable_red)),
           retransmission_ssrc_(enable_rtx ? kSendRtxSsrcs[0]
                                           : kVideoSendSsrcs[0]),
           retransmission_payload_type_(GetPayloadType(enable_rtx, enable_red)),
           encoder_(VideoEncoder::Create(VideoEncoder::EncoderType::kVp8)),
           marker_bits_observed_(0),
-          num_packets_observed_(0),
           retransmitted_timestamp_(0),
           frame_retransmitted_(false) {}
 
    private:
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       rtc::CritScope lock(&crit_);
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
-      // We accept some padding or RTX packets in the beginning to enable
-      // bitrate probing.
-      if (num_packets_observed_++ < kMinProbePackets &&
-          header.payloadType != payload_type_) {
-        EXPECT_TRUE(retransmission_payload_type_ == header.payloadType ||
-                    length == header.headerLength + header.paddingLength);
-        return SEND_PACKET;
+      // Ignore padding-only packets over RTX.
+      if (header.payloadType != payload_type_) {
+        EXPECT_EQ(retransmission_ssrc_, header.ssrc);
+        if (length == header.headerLength + header.paddingLength)
+          return SEND_PACKET;
       }
+
       if (header.timestamp == retransmitted_timestamp_) {
         EXPECT_EQ(retransmission_ssrc_, header.ssrc);
         EXPECT_EQ(retransmission_payload_type_, header.payloadType);
         frame_retransmitted_ = true;
         return SEND_PACKET;
       }
 
       EXPECT_EQ(kVideoSendSsrcs[0], header.ssrc)
           << "Payload type " << static_cast<int>(header.payloadType)
           << " not expected.";
@@ skipping 69 matching lines @@
       return kFakeVideoSendPayloadType;
     }
 
     rtc::CriticalSection crit_;
     const int payload_type_;
     const uint32_t retransmission_ssrc_;
     const int retransmission_payload_type_;
     rtc::scoped_ptr<VideoEncoder> encoder_;
     const std::string payload_name_;
     int marker_bits_observed_;
-    int num_packets_observed_;
     uint32_t retransmitted_timestamp_ GUARDED_BY(&crit_);
     bool frame_retransmitted_;
   } test(enable_rtx, enable_red);
 
   RunBaseTest(&test);
 }
 
 TEST_F(EndToEndTest, DecodesRetransmittedFrame) {
   DecodesRetransmittedFrame(false, false);
 }
@@ skipping 2700 matching lines @@
    private:
     bool video_observed_;
     bool audio_observed_;
     SequenceNumberUnwrapper unwrapper_;
     std::set<int64_t> received_packet_ids_;
   } test;
 
   RunBaseTest(&test);
 }
 }  // namespace webrtc