Add NACK rate throttling for audio channels.

webrtc/video/end_to_end_tests.cc

Index: webrtc/video/end_to_end_tests.cc
diff --git a/webrtc/video/end_to_end_tests.cc b/webrtc/video/end_to_end_tests.cc
index d0e99ab55df60e457ad2a75bbf09056dd2e83156..7172acf638b4694370c99930be7225b28e882c74 100644
--- a/webrtc/video/end_to_end_tests.cc
+++ b/webrtc/video/end_to_end_tests.cc
@@ -19,12 +19,14 @@
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/event.h"
+#include "webrtc/base/optional.h"
 #include "webrtc/call.h"
 #include "webrtc/call/transport_adapter.h"
 #include "webrtc/common_video/include/frame_callback.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"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
@@ -48,6 +50,7 @@
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/test/testsupport/perf_test.h"
 #include "webrtc/video_encoder.h"
+#include "webrtc/voice_engine/channel_proxy.h"
 
 namespace webrtc {
 
@@ -487,6 +490,78 @@ TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
   RunBaseTest(&test);
 }
 
+TEST_F(EndToEndTest, ReceivesNackAndRetransmitsAudio) {

[stefan-webrtc, 2016/07/28 07:27:38]

Is there any chance we could merge this test with the one above, or do both need
to be that media type dependent that it's not possible?

[sprang_webrtc, 2016/07/28 13:00:58]

The big difference here is that for video, we drop rtp packets and check that
the receiver sends nacks. That's not gonna work for audio, I need to manually
inject NACK packets into the sender...

[stefan-webrtc, 2016/07/28 15:06:15]

Acknowledged.

+  class NackObserver : public test::EndToEndTest {
+   public:
+    explicit NackObserver(std::unique_ptr<voe::ChannelProxy>* send_channel)
+        : EndToEndTest(kLongTimeoutMs),
+          local_ssrc_(0),
+          remote_ssrc_(0),
+          send_stream_(nullptr),
+          send_channel_(send_channel) {}
+
+   private:
+    void OnAudioStreamsCreated(
+        AudioSendStream* send_stream,
+        const std::vector<AudioReceiveStream*>& receive_streams) override {
+      send_stream_ = send_stream;
+    }
+
+    size_t GetNumVideoStreams() const override { return 0; }
+    size_t GetNumAudioStreams() const override { return 1; }
+
+    Action OnSendRtp(const uint8_t* packet, size_t length) override {
+      RTPHeader header;
+      EXPECT_TRUE(parser_->Parse(packet, length, &header));
+
+      if (!sequence_number_to_retransmit_) {
+        sequence_number_to_retransmit_ =
+            rtc::Optional<uint16_t>(header.sequenceNumber);
+
+        // Don't ask for retransmission straight away, may be deduped in pacer.
+      } else if (header.sequenceNumber == *sequence_number_to_retransmit_) {
+        observation_complete_.Set();
+      } else {
+        // Send a NACK as often as necessary until retransmission is received.
+        rtcp::Nack nack;
+        nack.From(local_ssrc_);
+        nack.To(remote_ssrc_);
+        uint16_t nack_list[] = {*sequence_number_to_retransmit_};
+        nack.WithList(nack_list, 1);
+        rtc::Buffer buffer = nack.Build();
+
+        EXPECT_TRUE(
+            (*send_channel_)->ReceivedRTCPPacket(buffer.data(), buffer.size()));

[stefan-webrtc, 2016/07/28 07:27:38]

Why can't we insert the rtcp packet the regular way via Call::DeliverPacket? I
think ChannelProxy was meant to be an internal  class and not an API.

[sprang_webrtc, 2016/07/28 13:00:58]

Yep. I had totally missed the Call::Receiver() method. I tried getting at
internal::AudioSendStream::DeliverRtcp(), but that's an internal class that
can't really be accessed from this class so I tried to get at it via a backdoor
:)

Removed all channelproxy changes and use Call instead. Thanks!

+      }
+
+      return SEND_PACKET;
+    }
+
+    void ModifyAudioConfigs(
+        AudioSendStream::Config* send_config,
+        std::vector<AudioReceiveStream::Config>* receive_configs) override {
+      send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
+      (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
+      local_ssrc_ = (*receive_configs)[0].rtp.local_ssrc;
+      remote_ssrc_ = (*receive_configs)[0].rtp.remote_ssrc;
+    }
+
+    void PerformTest() override {
+      EXPECT_TRUE(Wait())
+          << "Timed out waiting for packets to be NACKed, retransmitted and "
+             "rendered.";
+    }
+
+    uint32_t local_ssrc_;
+    uint32_t remote_ssrc_;
+    AudioSendStream* send_stream_;
+    rtc::Optional<uint16_t> sequence_number_to_retransmit_;
+    std::unique_ptr<voe::ChannelProxy>* send_channel_;
+  } test(&audio_send_channel_proxy_);
+
+  RunBaseTest(&test);
+}
+
 TEST_F(EndToEndTest, CanReceiveFec) {
   class FecRenderObserver : public test::EndToEndTest,
                             public rtc::VideoSinkInterface<VideoFrame> {