Making FakeNetworkPipe demux audio and video packets.

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 48 matching lines @@
 #if defined(MEMORY_SANITIZER)
 // Flaky under MemorySanitizer, see
 // https://bugs.chromium.org/p/webrtc/issues/detail?id=7419
 #define MAYBE_InitialProbing DISABLED_InitialProbing
 #else
 #define MAYBE_InitialProbing InitialProbing
 #endif
 
 namespace webrtc {
 
-static const int kSilenceTimeoutMs = 2000;
+namespace {
+constexpr int kSilenceTimeoutMs = 2000;
+}
 
 class EndToEndTest : public test::CallTest {
  public:
   EndToEndTest() {}
 
   virtual ~EndToEndTest() {
     EXPECT_EQ(nullptr, video_send_stream_);
     EXPECT_TRUE(video_receive_streams_.empty());
   }
 
@@ skipping 123 matching lines @@
       event_.Set();
     }
 
     bool Wait() { return event_.Wait(kDefaultTimeoutMs); }
 
     rtc::Event event_;
   } renderer;
 
   CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
 
-  test::DirectTransport sender_transport(
-      sender_call_.get(), MediaType::VIDEO);
-  test::DirectTransport receiver_transport(
-      receiver_call_.get(), MediaType::VIDEO);
+  test::DirectTransport sender_transport(sender_call_.get(), payload_type_map_);
+  test::DirectTransport receiver_transport(receiver_call_.get(),
+                                           payload_type_map_);
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
   CreateSendConfig(1, 0, 0, &sender_transport);
   CreateMatchingReceiveConfigs(&receiver_transport);
 
   video_receive_configs_[0].renderer = &renderer;
 
   CreateVideoStreams();
   Start();
@@ skipping 26 matching lines @@
 
     void OnFrame(const VideoFrame& video_frame) override { event_.Set(); }
 
     bool Wait() { return event_.Wait(kDefaultTimeoutMs); }
 
     rtc::Event event_;
   } renderer;
 
   CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
 
-  test::DirectTransport sender_transport(
-      sender_call_.get(), MediaType::VIDEO);
-  test::DirectTransport receiver_transport(
-      receiver_call_.get(), MediaType::VIDEO);
+  test::DirectTransport sender_transport(sender_call_.get(), payload_type_map_);
+  test::DirectTransport receiver_transport(receiver_call_.get(),
+                                           payload_type_map_);
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
   CreateSendConfig(1, 0, 0, &sender_transport);
   CreateMatchingReceiveConfigs(&receiver_transport);
   video_receive_configs_[0].renderer = &renderer;
 
   CreateVideoStreams();
   Start();
 
@@ skipping 39 matching lines @@
     EXPECT_TRUE(Wait())
         << "Timed out while waiting for enough frames to be decoded.";
   }
 
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
       std::vector<VideoReceiveStream::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     send_config->encoder_settings.encoder = encoder_.get();
     send_config->encoder_settings.payload_name = payload_name_;
-    send_config->encoder_settings.payload_type = 126;
+    send_config->encoder_settings.payload_type =
+        test::CallTest::kVideoSendPayloadType;
 
     (*receive_configs)[0].renderer = this;
     (*receive_configs)[0].decoders.resize(1);
     (*receive_configs)[0].decoders[0].payload_type =
         send_config->encoder_settings.payload_type;
     (*receive_configs)[0].decoders[0].payload_name =
         send_config->encoder_settings.payload_name;
     (*receive_configs)[0].decoders[0].decoder = decoder_.get();
   }
 
@@ skipping 190 matching lines @@
           local_ssrc_(0),
           remote_ssrc_(0),
           receive_transport_(nullptr) {}
 
    private:
     size_t GetNumVideoStreams() const override { return 0; }
     size_t GetNumAudioStreams() const override { return 1; }
 
     test::PacketTransport* CreateReceiveTransport() override {
       test::PacketTransport* receive_transport = new test::PacketTransport(
-          nullptr, this, test::PacketTransport::kReceiver,
-          MediaType::AUDIO,
+          nullptr, this, test::PacketTransport::kReceiver, payload_type_map_,
           FakeNetworkPipe::Config());
       receive_transport_ = receive_transport;
       return receive_transport;
     }
 
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
       if (!sequence_number_to_retransmit_) {
@@ skipping 242 matching lines @@
     return SEND_PACKET;
   }
 
   test::PacketTransport* CreateSendTransport(Call* sender_call) override {
     // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
     const int kNetworkDelayMs = 100;
     FakeNetworkPipe::Config config;
     config.queue_delay_ms = kNetworkDelayMs;
     return new test::PacketTransport(sender_call, this,
                                      test::PacketTransport::kSender,
-                                     MediaType::VIDEO, config);
+                                     test::CallTest::payload_type_map_, config);
   }
 
   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 = dropped_timestamps_.find(video_frame.timestamp());
     if (it != dropped_timestamps_.end()) {
       if (!expect_flexfec_rtcp_ || received_flexfec_rtcp_) {
         observation_complete_.Set();
@@ skipping 159 matching lines @@
     }
 
     test::PacketTransport* CreateSendTransport(Call* sender_call) override {
       // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
       // Configure some network delay.
       const int kNetworkDelayMs = 50;
       FakeNetworkPipe::Config config;
       config.queue_delay_ms = kNetworkDelayMs;
       return new test::PacketTransport(sender_call, this,
                                        test::PacketTransport::kSender,
-                                       MediaType::VIDEO, config);
+                                       payload_type_map_, config);
     }
 
     // TODO(holmer): Investigate why we don't send FEC packets when the bitrate
     // is 10 kbps.
     Call::Config GetSenderCallConfig() override {
       Call::Config config(event_log_.get());
       const int kMinBitrateBps = 30000;
       config.bitrate_config.min_bitrate_bps = kMinBitrateBps;
       return config;
     }
@@ skipping 321 matching lines @@
         return delivery_status;
       }
     }
 
     PacketReceiver* receiver_;
     rtc::Event delivered_packet_;
   };
 
   CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
 
-  test::DirectTransport send_transport(
-      sender_call_.get(), MediaType::VIDEO);
-  test::DirectTransport receive_transport(
-      receiver_call_.get(), MediaType::VIDEO);
+  test::DirectTransport send_transport(sender_call_.get(), payload_type_map_);
+  test::DirectTransport receive_transport(receiver_call_.get(),
+                                          payload_type_map_);
   PacketInputObserver input_observer(receiver_call_->Receiver());
   send_transport.SetReceiver(&input_observer);
   receive_transport.SetReceiver(sender_call_->Receiver());
 
   CreateSendConfig(1, 0, 0, &send_transport);
   CreateMatchingReceiveConfigs(&receive_transport);
 
   CreateVideoStreams();
   CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
                                kDefaultHeight);
@@ skipping 99 matching lines @@
 }
 
 TEST_F(EndToEndTest, UsesRtcpReducedSizeMode) {
   RespectsRtcpMode(RtcpMode::kReducedSize);
 }
 
 // Test sets up a Call multiple senders with different resolutions and SSRCs.
 // Another is set up to receive all three of these with different renderers.
 class MultiStreamTest {
  public:
-  static const size_t kNumStreams = 3;
+  static constexpr size_t kNumStreams = 3;
+  const uint8_t kVideoPayloadType = 124;
+  const std::map<uint8_t, MediaType> payload_type_map_ = {
+      {kVideoPayloadType, MediaType::VIDEO}};
+
   struct CodecSettings {
     uint32_t ssrc;
     int width;
     int height;
   } codec_settings[kNumStreams];
 
   MultiStreamTest() {
     // TODO(sprang): Cleanup when msvc supports explicit initializers for array.
     codec_settings[0] = {1, 640, 480};
     codec_settings[1] = {2, 320, 240};
@@ skipping 25 matching lines @@
     std::vector<std::unique_ptr<VideoDecoder>> allocated_decoders;
     for (size_t i = 0; i < kNumStreams; ++i) {
       uint32_t ssrc = codec_settings[i].ssrc;
       int width = codec_settings[i].width;
       int height = codec_settings[i].height;
 
       VideoSendStream::Config send_config(sender_transport.get());
       send_config.rtp.ssrcs.push_back(ssrc);
       send_config.encoder_settings.encoder = encoders[i].get();
       send_config.encoder_settings.payload_name = "VP8";
-      send_config.encoder_settings.payload_type = 124;
+      send_config.encoder_settings.payload_type = kVideoPayloadType;
       VideoEncoderConfig encoder_config;
       test::FillEncoderConfiguration(1, &encoder_config);
       encoder_config.max_bitrate_bps = 100000;
 
       UpdateSendConfig(i, &send_config, &encoder_config, &frame_generators[i]);
 
       send_streams[i] = sender_call->CreateVideoSendStream(
           send_config.Copy(), encoder_config.Copy());
       send_streams[i]->Start();
 
@@ skipping 40 matching lines @@
   // start flowing should this be dereferenced.
   virtual void UpdateSendConfig(
       size_t stream_index,
       VideoSendStream::Config* send_config,
       VideoEncoderConfig* encoder_config,
       test::FrameGeneratorCapturer** frame_generator) {}
   virtual void UpdateReceiveConfig(size_t stream_index,
                                    VideoReceiveStream::Config* receive_config) {
   }
   virtual test::DirectTransport* CreateSendTransport(Call* sender_call) {
-    return new test::DirectTransport(sender_call, MediaType::VIDEO);
+    return new test::DirectTransport(sender_call, payload_type_map_);
   }
   virtual test::DirectTransport* CreateReceiveTransport(Call* receiver_call) {
-    return new test::DirectTransport(receiver_call, MediaType::VIDEO);
+    return new test::DirectTransport(receiver_call, payload_type_map_);
   }
 };
 
 // Each renderer verifies that it receives the expected resolution, and as soon
 // as every renderer has received a frame, the test finishes.
 TEST_F(EndToEndTest, SendsAndReceivesMultipleStreams) {
   class VideoOutputObserver : public rtc::VideoSinkInterface<VideoFrame> {
    public:
     VideoOutputObserver(const MultiStreamTest::CodecSettings& settings,
                         uint32_t ssrc,
@@ skipping 55 matching lines @@
   } tester;
 
   tester.RunTest();
 }
 
 TEST_F(EndToEndTest, AssignsTransportSequenceNumbers) {
   static const int kExtensionId = 5;
 
   class RtpExtensionHeaderObserver : public test::DirectTransport {
    public:
-    RtpExtensionHeaderObserver(Call* sender_call,
-                               const uint32_t& first_media_ssrc,
-                               const std::map<uint32_t, uint32_t>& ssrc_map)
-        : DirectTransport(sender_call, MediaType::VIDEO),
+    RtpExtensionHeaderObserver(
+        Call* sender_call,
+        const uint32_t& first_media_ssrc,
+        const std::map<uint32_t, uint32_t>& ssrc_map,
+        const std::map<uint8_t, MediaType>& payload_type_map)
+        : DirectTransport(sender_call, payload_type_map),
           done_(false, false),
           parser_(RtpHeaderParser::Create()),
           first_media_ssrc_(first_media_ssrc),
           rtx_to_media_ssrcs_(ssrc_map),
           padding_observed_(false),
           rtx_padding_observed_(false),
           retransmit_observed_(false),
           started_(false) {
       parser_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
                                           kExtensionId);
@@ skipping 143 matching lines @@
         size_t stream_index,
         VideoReceiveStream::Config* receive_config) override {
       receive_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       receive_config->rtp.extensions.clear();
       receive_config->rtp.extensions.push_back(RtpExtension(
           RtpExtension::kTransportSequenceNumberUri, kExtensionId));
       receive_config->renderer = &fake_renderer_;
     }
 
     test::DirectTransport* CreateSendTransport(Call* sender_call) override {
-      observer_ = new RtpExtensionHeaderObserver(sender_call, first_media_ssrc_,
-                                                 rtx_to_media_ssrcs_);
+      std::map<uint8_t, MediaType> payload_type_map =
+          MultiStreamTest::payload_type_map_;
+      RTC_DCHECK(payload_type_map.find(kSendRtxPayloadType) ==
+                 payload_type_map.end());
+      payload_type_map[kSendRtxPayloadType] = MediaType::VIDEO;
+      observer_ =
+          new RtpExtensionHeaderObserver(sender_call, first_media_ssrc_,
+                                         rtx_to_media_ssrcs_, payload_type_map);
       return observer_;
     }
 
    private:
     test::FakeVideoRenderer fake_renderer_;
     uint32_t first_media_ssrc_;
     std::map<uint32_t, uint32_t> rtx_to_media_ssrcs_;
     RtpExtensionHeaderObserver* observer_;
   } tester;
 
@@ skipping 130 matching lines @@
     size_t length_;
     FrameType frame_type_;
     rtc::Event called_;
   };
 
   EncodedFrameTestObserver post_encode_observer;
   EncodedFrameTestObserver pre_decode_observer;
 
   CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
 
-  test::DirectTransport sender_transport(
-      sender_call_.get(), MediaType::VIDEO);
-  test::DirectTransport receiver_transport(
-      receiver_call_.get(), MediaType::VIDEO);
+  test::DirectTransport sender_transport(sender_call_.get(), payload_type_map_);
+  test::DirectTransport receiver_transport(receiver_call_.get(),
+                                           payload_type_map_);
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
   CreateSendConfig(1, 0, 0, &sender_transport);
   CreateMatchingReceiveConfigs(&receiver_transport);
   video_send_config_.post_encode_callback = &post_encode_observer;
   video_receive_configs_[0].pre_decode_callback = &pre_decode_observer;
 
   CreateVideoStreams();
   Start();
@@ skipping 142 matching lines @@
           poller_thread_(&BitrateStatsPollingThread,
                          this,
                          "BitrateStatsPollingThread"),
           state_(kWaitForFirstRampUp),
           retransmission_rate_limiter_(clock_, 1000) {}
 
     ~BweObserver() {}
 
     test::PacketTransport* CreateReceiveTransport() override {
       receive_transport_ = new test::PacketTransport(
-          nullptr, this, test::PacketTransport::kReceiver,
-          MediaType::VIDEO,
+          nullptr, this, test::PacketTransport::kReceiver, payload_type_map_,
           FakeNetworkPipe::Config());
       return receive_transport_;
     }
 
     Call::Config GetSenderCallConfig() override {
       Call::Config config(event_log_.get());
       // Set a high start bitrate to reduce the test completion time.
       config.bitrate_config.start_bitrate_bps = remb_bitrate_bps_;
       return config;
     }
@@ skipping 971 matching lines @@
       for (const auto& stat : stats_map) {
         if (!stat.second)
           return false;
       }
       return true;
     }
 
     test::PacketTransport* CreateSendTransport(Call* sender_call) override {
       FakeNetworkPipe::Config network_config;
       network_config.loss_percent = 5;
-      return new test::PacketTransport(
-          sender_call, this, test::PacketTransport::kSender, MediaType::VIDEO,
-          network_config);
+      return new test::PacketTransport(sender_call, this,
+                                       test::PacketTransport::kSender,
+                                       payload_type_map_, network_config);
     }
 
     Call::Config GetSenderCallConfig() override {
       Call::Config config = EndToEndTest::GetSenderCallConfig();
       config.bitrate_config.start_bitrate_bps = kStartBitrateBps;
       return config;
     }
 
     // This test use other VideoStream settings than the the default settings
     // implemented in DefaultVideoStreamFactory. Therefore  this test implement
@@ skipping 531 matching lines @@
     std::map<uint32_t, bool> ssrc_is_rtx_;
 
     rtc::CriticalSection crit_;
     size_t ssrcs_to_observe_ GUARDED_BY(crit_);
     std::map<uint32_t, bool> ssrc_observed_ GUARDED_BY(crit_);
   } observer(use_rtx);
 
   Call::Config config(event_log_.get());
   CreateCalls(config, config);
 
-  test::PacketTransport send_transport(sender_call_.get(), &observer,
-                                       test::PacketTransport::kSender,
-                                       MediaType::VIDEO,
-                                       FakeNetworkPipe::Config());
-  test::PacketTransport receive_transport(nullptr, &observer,
-                                          test::PacketTransport::kReceiver,
-                                          MediaType::VIDEO,
-                                          FakeNetworkPipe::Config());
+  test::PacketTransport send_transport(
+      sender_call_.get(), &observer, test::PacketTransport::kSender,
+      payload_type_map_, FakeNetworkPipe::Config());
+  test::PacketTransport receive_transport(
+      nullptr, &observer, test::PacketTransport::kReceiver, payload_type_map_,
+      FakeNetworkPipe::Config());
   send_transport.SetReceiver(receiver_call_->Receiver());
   receive_transport.SetReceiver(sender_call_->Receiver());
 
   CreateSendConfig(kNumSsrcs, 0, 0, &send_transport);
 
   if (use_rtx) {
     for (size_t i = 0; i < kNumSsrcs; ++i) {
       video_send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]);
     }
     video_send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
@@ skipping 271 matching lines @@
   RunBaseTest(&test);
 }
 
 TEST_F(EndToEndTest, CallReportsRttForSender) {
   static const int kSendDelayMs = 30;
   static const int kReceiveDelayMs = 70;
   CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
 
   FakeNetworkPipe::Config config;
   config.queue_delay_ms = kSendDelayMs;
-  test::DirectTransport sender_transport(
-      config, sender_call_.get(), MediaType::VIDEO);
+  test::DirectTransport sender_transport(config, sender_call_.get(),
+                                         payload_type_map_);
   config.queue_delay_ms = kReceiveDelayMs;
-  test::DirectTransport receiver_transport(
-      config, receiver_call_.get(), MediaType::VIDEO);
+  test::DirectTransport receiver_transport(config, receiver_call_.get(),
+                                           payload_type_map_);
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
   CreateSendConfig(1, 0, 0, &sender_transport);
   CreateMatchingReceiveConfigs(&receiver_transport);
 
   CreateVideoStreams();
   CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
                                kDefaultHeight);
   Start();
@@ skipping 41 matching lines @@
   DestroyStreams();
 }
 
 void EndToEndTest::VerifyNewVideoReceiveStreamsRespectNetworkState(
     MediaType network_to_bring_up,
     Transport* transport) {
   Call::Config config(event_log_.get());
   CreateCalls(config, config);
   receiver_call_->SignalChannelNetworkState(network_to_bring_up, kNetworkUp);
 
-  test::DirectTransport sender_transport(sender_call_.get(), MediaType::VIDEO);
+  test::DirectTransport sender_transport(sender_call_.get(), payload_type_map_);
   sender_transport.SetReceiver(receiver_call_->Receiver());
   CreateSendConfig(1, 0, 0, &sender_transport);
   CreateMatchingReceiveConfigs(transport);
   CreateVideoStreams();
   CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
                                kDefaultHeight);
 
   Start();
   SleepMs(kSilenceTimeoutMs);
   Stop();
@@ skipping 303 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