Add task queue to Call.

webrtc/video/video_send_stream_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>  // max
@@ skipping 848 matching lines @@
         if (stats.suspended == false) {
           // Stats flipped to false. Test is complete.
           observation_complete_.Set();
         }
         SendRtcpFeedback(0);  // REMB is only sent if value is > 0.
       }
 
       return SEND_PACKET;
     }
 
-    // This method implements the rtc::VideoSinkInterface
+    // This method implements the rtc::VideoSinkInterface. This is called when
+    // a frame is provided to the VideoSendStream.
     void OnFrame(const VideoFrame& video_frame) override {
       rtc::CritScope lock(&crit_);
       if (test_state_ == kDuringSuspend &&
           ++suspended_frame_count_ > kSuspendTimeFrames) {
         VideoSendStream::Stats stats = stream_->GetStats();
         EXPECT_TRUE(stats.suspended);
         SendRtcpFeedback(high_remb_bps_);
         test_state_ = kWaitingForPacket;
       }
     }
@@ skipping 318 matching lines @@
       VideoEncoderConfig* encoder_config) override {
     RTC_DCHECK_EQ(1u, encoder_config->streams.size());
     if (running_without_padding_) {
       encoder_config->min_transmit_bitrate_bps = 0;
       encoder_config->content_type =
           VideoEncoderConfig::ContentType::kRealtimeVideo;
     } else {
       encoder_config->min_transmit_bitrate_bps = kMinTransmitBitrateBps;
       encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen;
     }
-    encoder_config_ = *encoder_config;
+    encoder_config_ = encoder_config->Copy();
   }
 
   void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
     call_ = sender_call;
   }
 
   Action OnSendRtp(const uint8_t* packet, size_t length) override {
     rtc::CritScope lock(&crit_);
 
     if (running_without_padding_)
       EXPECT_EQ(0, call_->GetStats().max_padding_bitrate_bps);
 
     // Wait until at least kMinPacketsToSend frames have been encoded, so that
     // we have reliable data.
     if (++packets_sent_ < kMinPacketsToSend)
       return SEND_PACKET;
 
     if (running_without_padding_) {
       // We've sent kMinPacketsToSend packets with default configuration, switch
       // to enabling screen content and setting min transmit bitrate.
       packets_sent_ = 0;
       encoder_config_.min_transmit_bitrate_bps = kMinTransmitBitrateBps;
       encoder_config_.content_type = VideoEncoderConfig::ContentType::kScreen;
-      send_stream_->ReconfigureVideoEncoder(encoder_config_);
+      send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
       running_without_padding_ = false;
       return SEND_PACKET;
     }
 
     // Make sure the pacer has been configured with a min transmit bitrate.
     if (call_->GetStats().max_padding_bitrate_bps > 0)
       observation_complete_.Set();
 
     return SEND_PACKET;
   }
@@ skipping 74 matching lines @@
   video_send_config_.encoder_settings.encoder = &encoder;
 
   CreateVideoStreams();
 
   EXPECT_TRUE(encoder.WaitForStartBitrate());
   EXPECT_EQ(video_encoder_config_.streams[0].max_bitrate_bps / 1000,
             encoder.GetStartBitrateKbps());
 
   video_encoder_config_.streams[0].max_bitrate_bps =
       2 * bitrate_config.start_bitrate_bps;
-  video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_);
+  video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_.Copy());
 
   // New bitrate should be reconfigured above the previous max. As there's no
   // network connection this shouldn't be flaky, as no bitrate should've been
   // reported in between.
   EXPECT_TRUE(encoder.WaitForStartBitrate());
   EXPECT_EQ(bitrate_config.start_bitrate_bps / 1000,
             encoder.GetStartBitrateKbps());
 
   DestroyStreams();
 }
@@ skipping 244 matching lines @@
         VideoSendStream* send_stream,
         const std::vector<VideoReceiveStream*>& receive_streams) override {
       stream_ = send_stream;
     }
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder = this;
-      encoder_config_ = *encoder_config;
+      encoder_config_ = encoder_config->Copy();
     }
 
     void PerformTest() override {
       EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode.";
       EXPECT_EQ(0u, num_releases());
-      stream_->ReconfigureVideoEncoder(encoder_config_);
+      stream_->ReconfigureVideoEncoder(std::move(encoder_config_));
       EXPECT_EQ(0u, num_releases());
       stream_->Stop();
       // Encoder should not be released before destroying the VideoSendStream.
       EXPECT_FALSE(IsReleased());
       EXPECT_TRUE(IsReadyForEncode());
       stream_->Start();
       // Sanity check, make sure we still encode frames with this encoder.
       EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode.";
     }
 
@@ skipping 22 matching lines @@
           init_encode_event_(false, false),
           num_initializations_(0),
           stream_(nullptr) {}
 
    private:
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder = this;
-      encoder_config_ = *encoder_config;
+      encoder_config_ = encoder_config->Copy();
     }
 
     void OnVideoStreamsCreated(
         VideoSendStream* send_stream,
         const std::vector<VideoReceiveStream*>& receive_streams) override {
       stream_ = send_stream;
     }
 
     int32_t InitEncode(const VideoCodec* config,
                        int32_t number_of_cores,
                        size_t max_payload_size) override {
       if (num_initializations_ == 0) {
         // Verify default values.
         EXPECT_EQ(kRealtimeVideo, config->mode);
       } else {
         // Verify that changed values are propagated.
         EXPECT_EQ(kScreensharing, config->mode);
       }
       ++num_initializations_;
       init_encode_event_.Set();
       return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
     }
 
     void PerformTest() override {
       EXPECT_TRUE(init_encode_event_.Wait(kDefaultTimeoutMs));
       EXPECT_EQ(1u, num_initializations_) << "VideoEncoder not initialized.";
 
       encoder_config_.content_type = VideoEncoderConfig::ContentType::kScreen;
-      stream_->ReconfigureVideoEncoder(encoder_config_);
+      stream_->ReconfigureVideoEncoder(std::move(encoder_config_));
       EXPECT_TRUE(init_encode_event_.Wait(kDefaultTimeoutMs));
       EXPECT_EQ(2u, num_initializations_)
           << "ReconfigureVideoEncoder did not reinitialize the encoder with "
              "new encoder settings.";
     }
 
     rtc::Event init_encode_event_;
     size_t num_initializations_;
     VideoSendStream* stream_;
     VideoEncoderConfig encoder_config_;
@@ skipping 26 matching lines @@
       VideoEncoderConfig* encoder_config) override {
     send_config->encoder_settings.encoder = this;
     send_config->encoder_settings.payload_name = codec_name_;
 
     for (size_t i = 0; i < encoder_config->streams.size(); ++i) {
       encoder_config->streams[i].temporal_layer_thresholds_bps.resize(
           kVideoCodecConfigObserverNumberOfTemporalLayers - 1);
     }
 
     encoder_config->encoder_specific_settings = &encoder_settings_;
-    encoder_config_ = *encoder_config;
+    encoder_config_ = encoder_config->Copy();
   }
 
   void OnVideoStreamsCreated(
       VideoSendStream* send_stream,
       const std::vector<VideoReceiveStream*>& receive_streams) override {
     stream_ = send_stream;
   }
 
   int32_t InitEncode(const VideoCodec* config,
                      int32_t number_of_cores,
                      size_t max_payload_size) override {
     EXPECT_EQ(video_codec_type_, config->codecType);
     VerifyCodecSpecifics(*config);
     ++num_initializations_;
     init_encode_event_.Set();
     return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
   }
 
   void VerifyCodecSpecifics(const VideoCodec& config) const;
 
   void PerformTest() override {
     EXPECT_TRUE(
         init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs));
     ASSERT_EQ(1u, num_initializations_) << "VideoEncoder not initialized.";
 
     encoder_settings_.frameDroppingOn = true;
-    stream_->ReconfigureVideoEncoder(encoder_config_);
+    stream_->ReconfigureVideoEncoder(std::move(encoder_config_));
     ASSERT_TRUE(
         init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs));
     EXPECT_EQ(2u, num_initializations_)
         << "ReconfigureVideoEncoder did not reinitialize the encoder with "
            "new encoder settings.";
   }
 
   int32_t Encode(const VideoFrame& input_image,
                  const CodecSpecificInfo* codec_specific_info,
                  const std::vector<FrameType>* frame_types) override {
@@ skipping 176 matching lines @@
   static const int kMaxBitrateKbps = 413;
   static const int kIncreasedStartBitrateKbps = 451;
   static const int kIncreasedMaxBitrateKbps = 597;
   class EncoderBitrateThresholdObserver : public test::SendTest,
                                           public test::FakeEncoder {
    public:
     EncoderBitrateThresholdObserver()
         : SendTest(kDefaultTimeoutMs),
           FakeEncoder(Clock::GetRealTimeClock()),
           init_encode_event_(false, false),
+          bitrate_changed_event_(false, false),
+          target_bitrate_(0),
           num_initializations_(0),
           call_(nullptr),
           send_stream_(nullptr) {}
 
    private:
     int32_t InitEncode(const VideoCodec* codecSettings,
                        int32_t numberOfCores,
                        size_t maxPayloadSize) override {
+      EXPECT_GE(codecSettings->startBitrate, codecSettings->minBitrate);
+      EXPECT_LE(codecSettings->startBitrate, codecSettings->maxBitrate);
       if (num_initializations_ == 0) {
         EXPECT_EQ(static_cast<unsigned int>(kMinBitrateKbps),
                   codecSettings->minBitrate);
         EXPECT_EQ(static_cast<unsigned int>(kStartBitrateKbps),
                   codecSettings->startBitrate);
         EXPECT_EQ(static_cast<unsigned int>(kMaxBitrateKbps),
                   codecSettings->maxBitrate);
         observation_complete_.Set();
       } else if (num_initializations_ == 1) {
         EXPECT_EQ(static_cast<unsigned int>(kLowerMaxBitrateKbps),
                   codecSettings->maxBitrate);
         // The start bitrate should be kept (-1) and capped to the max bitrate.
         // Since this is not an end-to-end call no receiver should have been
         // returning a REMB that could lower this estimate.
         EXPECT_EQ(codecSettings->startBitrate, codecSettings->maxBitrate);
       } else if (num_initializations_ == 2) {
         EXPECT_EQ(static_cast<unsigned int>(kIncreasedMaxBitrateKbps),
                   codecSettings->maxBitrate);
-        EXPECT_EQ(static_cast<unsigned int>(kIncreasedStartBitrateKbps),
-                  codecSettings->startBitrate);
+        // The start bitrate will be whatever the rate BitRateController
+        // has currently configured but in the span of the set max and min
+        // bitrate.
       }
       ++num_initializations_;
       init_encode_event_.Set();
       return FakeEncoder::InitEncode(codecSettings, numberOfCores,
                                      maxPayloadSize);
     }
 
+    int32_t SetRates(uint32_t newBitRate, uint32_t frameRate) override {
+      {
+        rtc::CritScope lock(&crit_);
+        target_bitrate_ = newBitRate;
+      }
+      bitrate_changed_event_.Set();
+      return FakeEncoder::SetRates(newBitRate, frameRate);
+    }
+
+    void WaitForSetRates(uint32_t expected_bitrate) {
+      EXPECT_TRUE(
+          bitrate_changed_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs))
+          << "Timed out while waiting encoder rate to be set.";
+      rtc::CritScope lock(&crit_);
+      EXPECT_EQ(expected_bitrate, target_bitrate_);
+    }
+
     Call::Config GetSenderCallConfig() override {
       Call::Config config;
       config.bitrate_config.min_bitrate_bps = kMinBitrateKbps * 1000;
       config.bitrate_config.start_bitrate_bps = kStartBitrateKbps * 1000;
       config.bitrate_config.max_bitrate_bps = kMaxBitrateKbps * 1000;
       return config;
     }
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder = this;
       // Set bitrates lower/higher than min/max to make sure they are properly
       // capped.
       encoder_config->streams.front().min_bitrate_bps = kMinBitrateKbps * 1000;
       encoder_config->streams.front().max_bitrate_bps = kMaxBitrateKbps * 1000;
-      encoder_config_ = *encoder_config;
+      encoder_config_ = encoder_config->Copy();
     }
 
     void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
       call_ = sender_call;
     }
 
     void OnVideoStreamsCreated(
         VideoSendStream* send_stream,
         const std::vector<VideoReceiveStream*>& receive_streams) override {
       send_stream_ = send_stream;
     }
 
     void PerformTest() override {
       ASSERT_TRUE(
           init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs))
-          << "Timed out while waiting encoder to be configured.";
+          << "Timed out while waiting for encoder to be configured.";
+      WaitForSetRates(kStartBitrateKbps);
       Call::Config::BitrateConfig bitrate_config;
       bitrate_config.start_bitrate_bps = kIncreasedStartBitrateKbps * 1000;
       bitrate_config.max_bitrate_bps = kIncreasedMaxBitrateKbps * 1000;
       call_->SetBitrateConfig(bitrate_config);
-      EXPECT_TRUE(Wait())
-          << "Timed out while waiting encoder to be configured.";
+      // Encoder rate is capped by EncoderConfig max_bitrate_bps.
+      WaitForSetRates(kMaxBitrateKbps);
+
       encoder_config_.streams[0].min_bitrate_bps = 0;
       encoder_config_.streams[0].max_bitrate_bps = kLowerMaxBitrateKbps * 1000;
-      send_stream_->ReconfigureVideoEncoder(encoder_config_);
+      send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
       ASSERT_TRUE(
           init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs));
       EXPECT_EQ(2, num_initializations_)
           << "Encoder should have been reconfigured with the new value.";
+      WaitForSetRates(kLowerMaxBitrateKbps);
+
       encoder_config_.streams[0].target_bitrate_bps =
           encoder_config_.streams[0].min_bitrate_bps;
       encoder_config_.streams[0].max_bitrate_bps =
           kIncreasedMaxBitrateKbps * 1000;
-      send_stream_->ReconfigureVideoEncoder(encoder_config_);
+      send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
       ASSERT_TRUE(
           init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs));
       EXPECT_EQ(3, num_initializations_)
           << "Encoder should have been reconfigured with the new value.";
+      // Expected target bitrate is the start bitrate set in the call to
+      // call_->SetBitrateConfig.
+      WaitForSetRates(kIncreasedStartBitrateKbps);
     }
 
     rtc::Event init_encode_event_;
+    rtc::Event bitrate_changed_event_;
+    rtc::CriticalSection crit_;
+    uint32_t target_bitrate_ GUARDED_BY(&crit_);
     int num_initializations_;
     webrtc::Call* call_;
     webrtc::VideoSendStream* send_stream_;
     webrtc::VideoEncoderConfig encoder_config_;
   } test;
 
   RunBaseTest(&test);
 }
 
 TEST_F(VideoSendStreamTest, ReportsSentResolution) {
@@ skipping 101 matching lines @@
       std::vector<VideoReceiveStream::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
     encoder_config->encoder_specific_settings = &vp9_settings_;
     send_config->encoder_settings.encoder = vp9_encoder_.get();
     send_config->encoder_settings.payload_name = "VP9";
     send_config->encoder_settings.payload_type = kVp9PayloadType;
     ModifyVideoConfigsHook(send_config, receive_configs, encoder_config);
     EXPECT_EQ(1u, encoder_config->streams.size());
     encoder_config->streams[0].temporal_layer_thresholds_bps.resize(
         vp9_settings_.numberOfTemporalLayers - 1);
-    encoder_config_ = *encoder_config;
+    encoder_config_ = encoder_config->Copy();
   }
 
   void PerformTest() override {
     EXPECT_TRUE(Wait()) << "Test timed out waiting for VP9 packet, num frames "
                         << frames_sent_;
   }
 
   Action OnSendRtp(const uint8_t* packet, size_t length) override {
     RTPHeader header;
     EXPECT_TRUE(parser_->Parse(packet, length, &header));
@@ skipping 358 matching lines @@
         observation_complete_.Set();
       }
     }
   } test;
 
   RunBaseTest(&test);
 }
 #endif  // !defined(RTC_DISABLE_VP9)
 
 }  // namespace webrtc