Call OnSentPacket for all packets sent in the test framework.

webrtc/call/call_perf_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 40 matching lines @@
   void TestMinTransmitBitrate(bool pad_to_min_bitrate);
 
   void TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
                           int threshold_ms,
                           int start_time_ms,
                           int run_time_ms);
 };
 
 class SyncRtcpObserver : public test::RtpRtcpObserver {
  public:
-  explicit SyncRtcpObserver(const FakeNetworkPipe::Config& config)
-      : test::RtpRtcpObserver(CallPerfTest::kLongTimeoutMs, config) {}
+  SyncRtcpObserver() : test::RtpRtcpObserver(CallPerfTest::kLongTimeoutMs) {}
 
   Action OnSendRtcp(const uint8_t* packet, size_t length) override {
     RTCPUtility::RTCPParserV2 parser(packet, length, true);
     EXPECT_TRUE(parser.IsValid());
 
     for (RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
          packet_type != RTCPUtility::RTCPPacketTypes::kInvalid;
          packet_type = parser.Iterate()) {
       if (packet_type == RTCPUtility::RTCPPacketTypes::kSr) {
         const RTCPUtility::RTCPPacket& packet = parser.Packet();
@@ skipping 47 matching lines @@
 class VideoRtcpAndSyncObserver : public SyncRtcpObserver, public VideoRenderer {
   static const int kInSyncThresholdMs = 50;
   static const int kStartupTimeMs = 2000;
   static const int kMinRunTimeMs = 30000;
 
  public:
   VideoRtcpAndSyncObserver(Clock* clock,
                            int voe_channel,
                            VoEVideoSync* voe_sync,
                            SyncRtcpObserver* audio_observer)
-      : SyncRtcpObserver(FakeNetworkPipe::Config()),
-        clock_(clock),
+      : clock_(clock),
         voe_channel_(voe_channel),
         voe_sync_(voe_sync),
         audio_observer_(audio_observer),
         creation_time_ms_(clock_->TimeInMilliseconds()),
         first_time_in_sync_(-1) {}
 
   void RenderFrame(const VideoFrame& video_frame,
                    int time_to_render_ms) override {
     int64_t now_ms = clock_->TimeInMilliseconds();
     uint32_t playout_timestamp = 0;
@@ skipping 33 matching lines @@
       }
       if (time_since_creation > kMinRunTimeMs)
         observation_complete_->Set();
     }
   }
 
   bool IsTextureSupported() const override { return false; }
 
  private:
   Clock* const clock_;
-  int voe_channel_;
-  VoEVideoSync* voe_sync_;
-  SyncRtcpObserver* audio_observer_;
-  int64_t creation_time_ms_;
+  const int voe_channel_;
+  VoEVideoSync* const voe_sync_;
+  SyncRtcpObserver* const audio_observer_;
+  const int64_t creation_time_ms_;
   int64_t first_time_in_sync_;
 };
 
 void CallPerfTest::TestAudioVideoSync(bool fec, bool create_audio_first) {
   const char* kSyncGroup = "av_sync";
   class AudioPacketReceiver : public PacketReceiver {
    public:
     AudioPacketReceiver(int channel, VoENetwork* voe_network)
         : channel_(channel),
           voe_network_(voe_network),
@@ skipping 26 matching lines @@
   VoENetwork* voe_network = VoENetwork::GetInterface(voice_engine);
   VoEVideoSync* voe_sync = VoEVideoSync::GetInterface(voice_engine);
   const std::string audio_filename =
       test::ResourcePath("voice_engine/audio_long16", "pcm");
   ASSERT_STRNE("", audio_filename.c_str());
   test::FakeAudioDevice fake_audio_device(Clock::GetRealTimeClock(),
                                           audio_filename);
   EXPECT_EQ(0, voe_base->Init(&fake_audio_device, nullptr));
   int channel = voe_base->CreateChannel();
 
-  FakeNetworkPipe::Config net_config;
-  net_config.queue_delay_ms = 500;
-  net_config.loss_percent = 5;
-  SyncRtcpObserver audio_observer(net_config);
-  VideoRtcpAndSyncObserver observer(Clock::GetRealTimeClock(),
-                                    channel,
-                                    voe_sync,
-                                    &audio_observer);
+  SyncRtcpObserver audio_observer;
 
   Call::Config receiver_config;
   receiver_config.voice_engine = voice_engine;
   CreateCalls(Call::Config(), receiver_config);
 
   CodecInst isac = {103, "ISAC", 16000, 480, 1, 32000};
   EXPECT_EQ(0, voe_codec->SetSendCodec(channel, isac));
 
   AudioPacketReceiver voe_packet_receiver(channel, voe_network);
-  audio_observer.SetReceivers(&voe_packet_receiver, &voe_packet_receiver);
 
-  internal::TransportAdapter transport_adapter(audio_observer.SendTransport());
+  FakeNetworkPipe::Config net_config;
+  net_config.queue_delay_ms = 500;
+  net_config.loss_percent = 5;
+  test::PacketTransport audio_send_transport(
+      nullptr, &audio_observer, test::PacketTransport::kSender, net_config);
+  audio_send_transport.SetReceiver(&voe_packet_receiver);
+  test::PacketTransport audio_receive_transport(
+      nullptr, &audio_observer, test::PacketTransport::kReceiver, net_config);
+  audio_receive_transport.SetReceiver(&voe_packet_receiver);
+
+  internal::TransportAdapter transport_adapter(&audio_send_transport);
   transport_adapter.Enable();
   EXPECT_EQ(0,
             voe_network->RegisterExternalTransport(channel, transport_adapter));
 
-  observer.SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
+  VideoRtcpAndSyncObserver observer(Clock::GetRealTimeClock(), channel,
+                                    voe_sync, &audio_observer);
+
+  test::PacketTransport sync_send_transport(sender_call_.get(), &observer,
+                                            test::PacketTransport::kSender,
+                                            FakeNetworkPipe::Config());
+  sync_send_transport.SetReceiver(receiver_call_->Receiver());
+  test::PacketTransport sync_receive_transport(receiver_call_.get(), &observer,
+                                               test::PacketTransport::kReceiver,
+                                               FakeNetworkPipe::Config());
+  sync_receive_transport.SetReceiver(sender_call_->Receiver());
 
   test::FakeDecoder fake_decoder;
 
-  CreateSendConfig(1, observer.SendTransport());
-  CreateMatchingReceiveConfigs(observer.ReceiveTransport());
+  CreateSendConfig(1, &sync_send_transport);
+  CreateMatchingReceiveConfigs(&sync_receive_transport);
 
   send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
   if (fec) {
     send_config_.rtp.fec.red_payload_type = kRedPayloadType;
     send_config_.rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
     receive_configs_[0].rtp.fec.red_payload_type = kRedPayloadType;
     receive_configs_[0].rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
   }
   receive_configs_[0].rtp.nack.rtp_history_ms = 1000;
   receive_configs_[0].renderer = &observer;
@@ skipping 26 matching lines @@
 
   EXPECT_EQ(kEventSignaled, observer.Wait())
       << "Timed out while waiting for audio and video to be synchronized.";
 
   EXPECT_EQ(0, voe_base->StopSend(channel));
   EXPECT_EQ(0, voe_base->StopReceive(channel));
   EXPECT_EQ(0, voe_base->StopPlayout(channel));
   fake_audio_device.Stop();
 
   Stop();
-  observer.StopSending();
-  audio_observer.StopSending();
+  sync_send_transport.StopSending();
+  sync_receive_transport.StopSending();
+  audio_send_transport.StopSending();
+  audio_receive_transport.StopSending();
 
   voe_base->DeleteChannel(channel);
   voe_base->Release();
   voe_codec->Release();
   voe_network->Release();
   voe_sync->Release();
 
   DestroyStreams();
 
   receiver_call_->DestroyAudioReceiveStream(audio_receive_stream);
@@ skipping 15 matching lines @@
   TestAudioVideoSync(true, false);
 }
 
 void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
                                       int threshold_ms,
                                       int start_time_ms,
                                       int run_time_ms) {
   class CaptureNtpTimeObserver : public test::EndToEndTest,
                                  public VideoRenderer {
    public:
-    CaptureNtpTimeObserver(const FakeNetworkPipe::Config& config,
-                           int threshold_ms,
-                           int start_time_ms,
-                           int run_time_ms)
-        : EndToEndTest(kLongTimeoutMs, config),
+    CaptureNtpTimeObserver(int threshold_ms, int start_time_ms, int run_time_ms)
+        : EndToEndTest(kLongTimeoutMs),
           clock_(Clock::GetRealTimeClock()),
           threshold_ms_(threshold_ms),
           start_time_ms_(start_time_ms),
           run_time_ms_(run_time_ms),
           creation_time_ms_(clock_->TimeInMilliseconds()),
           capturer_(nullptr),
           rtp_start_timestamp_set_(false),
           rtp_start_timestamp_(0) {}
 
    private:
     void RenderFrame(const VideoFrame& video_frame,
                      int time_to_render_ms) override {
+      rtc::CritScope lock(&crit_);
       if (video_frame.ntp_time_ms() <= 0) {
         // Haven't got enough RTCP SR in order to calculate the capture ntp
         // time.
         return;
       }
 
       int64_t now_ms = clock_->TimeInMilliseconds();
       int64_t time_since_creation = now_ms - creation_time_ms_;
       if (time_since_creation < start_time_ms_) {
         // Wait for |start_time_ms_| before start measuring.
@@ skipping 20 matching lines @@
       ss << time_offset_ms;
 
       webrtc::test::PrintResult(
           "capture_ntp_time", "", "real - estimated", ss.str(), "ms", true);
       EXPECT_TRUE(std::abs(time_offset_ms) < threshold_ms_);
     }
 
     bool IsTextureSupported() const override { return false; }
 
     virtual Action OnSendRtp(const uint8_t* packet, size_t length) {
+      rtc::CritScope lock(&crit_);
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
       if (!rtp_start_timestamp_set_) {
         // Calculate the rtp timestamp offset in order to calculate the real
         // capture time.
         uint32_t first_capture_timestamp =
             90 * static_cast<uint32_t>(capturer_->first_frame_capture_time());
         rtp_start_timestamp_ = header.timestamp - first_capture_timestamp;
         rtp_start_timestamp_set_ = true;
@@ skipping 18 matching lines @@
       // Enable the receiver side rtt calculation.
       (*receive_configs)[0].rtp.rtcp_xr.receiver_reference_time_report = true;
     }
 
     void PerformTest() override {
       EXPECT_EQ(kEventSignaled, Wait()) << "Timed out while waiting for "
                                            "estimated capture NTP time to be "
                                            "within bounds.";
     }
 
-    Clock* clock_;
+    rtc::CriticalSection crit_;
+    Clock* const clock_;
     int threshold_ms_;
     int start_time_ms_;
     int run_time_ms_;
     int64_t creation_time_ms_;
     test::FrameGeneratorCapturer* capturer_;
     bool rtp_start_timestamp_set_;
     uint32_t rtp_start_timestamp_;
     typedef std::map<uint32_t, uint32_t> FrameCaptureTimeList;
-    FrameCaptureTimeList capture_time_list_;
-  } test(net_config, threshold_ms, start_time_ms, run_time_ms);
+    FrameCaptureTimeList capture_time_list_ GUARDED_BY(&crit_);
+  } test(threshold_ms, start_time_ms, run_time_ms);
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, net_config);
 }
 
 TEST_F(CallPerfTest, CaptureNtpTimeWithNetworkDelay) {
   FakeNetworkPipe::Config net_config;
   net_config.queue_delay_ms = 100;
   // TODO(wu): lower the threshold as the calculation/estimatation becomes more
   // accurate.
   const int kThresholdMs = 100;
   const int kStartTimeMs = 10000;
   const int kRunTimeMs = 20000;
@@ skipping 35 matching lines @@
 
     void PerformTest() override {
       EXPECT_EQ(kEventSignaled, Wait())
           << "Timed out before receiving an overuse callback.";
     }
 
     LoadObserver::Load tested_load_;
     test::DelayedEncoder encoder_;
   } test(tested_load, encode_delay_ms);
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(CallPerfTest, ReceivesCpuUnderuse) {
   const int kEncodeDelayMs = 2;
   TestCpuOveruse(LoadObserver::kUnderuse, kEncodeDelayMs);
 }
 
 TEST_F(CallPerfTest, ReceivesCpuOveruse) {
   const int kEncodeDelayMs = 35;
   TestCpuOveruse(LoadObserver::kOveruse, kEncodeDelayMs);
 }
 
 void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
   static const int kMaxEncodeBitrateKbps = 30;
   static const int kMinTransmitBitrateBps = 150000;
   static const int kMinAcceptableTransmitBitrate = 130;
   static const int kMaxAcceptableTransmitBitrate = 170;
   static const int kNumBitrateObservationsInRange = 100;
   static const int kAcceptableBitrateErrorMargin = 15;  // +- 7
-  class BitrateObserver : public test::EndToEndTest, public PacketReceiver {
+  class BitrateObserver : public test::EndToEndTest {
    public:
     explicit BitrateObserver(bool using_min_transmit_bitrate)
         : EndToEndTest(kLongTimeoutMs),
           send_stream_(nullptr),
-          send_transport_receiver_(nullptr),
           pad_to_min_bitrate_(using_min_transmit_bitrate),
           num_bitrate_observations_in_range_(0) {}
 
    private:
-    void SetReceivers(PacketReceiver* send_transport_receiver,
-                      PacketReceiver* receive_transport_receiver) override {
-      send_transport_receiver_ = send_transport_receiver;
-      test::RtpRtcpObserver::SetReceivers(this, receive_transport_receiver);
-    }
-
-    DeliveryStatus DeliverPacket(MediaType media_type,
-                                 const uint8_t* packet,
-                                 size_t length,
-                                 const PacketTime& packet_time) override {
+    // TODO(holmer): Run this with a timer instead of once per packet.
+    Action OnSendRtp(const uint8_t* packet, size_t length) override {
       VideoSendStream::Stats stats = send_stream_->GetStats();
       if (stats.substreams.size() > 0) {
         RTC_DCHECK_EQ(1u, stats.substreams.size());
         int bitrate_kbps =
             stats.substreams.begin()->second.total_bitrate_bps / 1000;
         if (bitrate_kbps > 0) {
           test::PrintResult(
               "bitrate_stats_",
               (pad_to_min_bitrate_ ? "min_transmit_bitrate"
                                    : "without_min_transmit_bitrate"),
@@ skipping 13 matching lines @@
                 bitrate_kbps < (kMaxEncodeBitrateKbps +
                                 kAcceptableBitrateErrorMargin / 2)) {
               ++num_bitrate_observations_in_range_;
             }
           }
           if (num_bitrate_observations_in_range_ ==
               kNumBitrateObservationsInRange)
             observation_complete_->Set();
         }
       }
-      return send_transport_receiver_->DeliverPacket(media_type, packet, length,
-                                                     packet_time);
+      return SEND_PACKET;
     }
 
     void OnStreamsCreated(
         VideoSendStream* send_stream,
         const std::vector<VideoReceiveStream*>& receive_streams) override {
       send_stream_ = send_stream;
     }
 
     void ModifyConfigs(VideoSendStream::Config* send_config,
                        std::vector<VideoReceiveStream::Config>* receive_configs,
                        VideoEncoderConfig* encoder_config) override {
       if (pad_to_min_bitrate_) {
         encoder_config->min_transmit_bitrate_bps = kMinTransmitBitrateBps;
       } else {
         RTC_DCHECK_EQ(0, encoder_config->min_transmit_bitrate_bps);
       }
     }
 
     void PerformTest() override {
       EXPECT_EQ(kEventSignaled, Wait())
           << "Timeout while waiting for send-bitrate stats.";
     }
 
     VideoSendStream* send_stream_;
-    PacketReceiver* send_transport_receiver_;
     const bool pad_to_min_bitrate_;
     int num_bitrate_observations_in_range_;
   } test(pad_to_min_bitrate);
 
   fake_encoder_.SetMaxBitrate(kMaxEncodeBitrateKbps);
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(CallPerfTest, PadsToMinTransmitBitrate) { TestMinTransmitBitrate(true); }
 
 TEST_F(CallPerfTest, NoPadWithoutMinTransmitBitrate) {
   TestMinTransmitBitrate(false);
 }
 
 TEST_F(CallPerfTest, KeepsHighBitrateWhenReconfiguringSender) {
   static const uint32_t kInitialBitrateKbps = 400;
@@ skipping 74 matching lines @@
     }
 
    private:
     rtc::scoped_ptr<webrtc::EventWrapper> time_to_reconfigure_;
     int encoder_inits_;
     uint32_t last_set_bitrate_;
     VideoSendStream* send_stream_;
     VideoEncoderConfig encoder_config_;
   } test;
 
-  RunBaseTest(&test);
+  RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 }  // namespace webrtc