Allows change of fake encoder max rate in scenarios tests.

Bug: webrtc:9510
Change-Id: I13010c7febe8c31de78178611915a2b9e2f9869f
Reviewed-on: https://webrtc-review.googlesource.com/c/110612
Reviewed-by: Erik Språng <sprang@webrtc.org>
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#25608}

test/fake_encoder.cc

@@ -65,6 +65,7 @@ void FakeEncoder::SetMaxBitrate(int max_kbps) {
   RTC_DCHECK_GE(max_kbps, -1);  // max_kbps == -1 disables it.
   rtc::CritScope cs(&crit_sect_);
   max_target_bitrate_kbps_ = max_kbps;
+  SetRateAllocation(target_bitrate_, configured_input_framerate_);
 }
 
 int32_t FakeEncoder::InitEncode(const VideoCodec* config,

test/scenario/scenario_config.h

@@ -111,6 +111,7 @@ struct VideoStreamConfig {
     absl::optional<int> key_frame_interval = 3000;
 
     absl::optional<DataRate> max_data_rate;
+    absl::optional<int> max_framerate;
     size_t num_simulcast_streams = 1;
     using DegradationPreference = DegradationPreference;
     DegradationPreference degradation_preference =

test/scenario/video_stream.cc

@@ -163,6 +163,12 @@ VideoEncoderConfig CreateVideoEncoderConfig(VideoStreamConfig config) {
   }
   encoder_config.encoder_specific_settings =
       CreateEncoderSpecificSettings(config);
+  if (config.encoder.max_framerate) {
+    for (auto& layer : encoder_config.simulcast_layers) {
+      layer.max_framerate = *config.encoder.max_framerate;
+    }
+  }
+
   return encoder_config;
 }
 }  // namespace
@@ -203,11 +209,13 @@ SendVideoStream::SendVideoStream(CallClient* sender,
     case Encoder::Implementation::kFake:
       if (config.encoder.codec == Codec::kVideoCodecGeneric) {
         encoder_factory_ =
-            absl::make_unique<FunctionVideoEncoderFactory>([this, config]() {
+            absl::make_unique<FunctionVideoEncoderFactory>([this]() {
+              rtc::CritScope cs(&crit_);
               auto encoder =
                   absl::make_unique<test::FakeEncoder>(sender_->clock_);
-              if (config.encoder.fake.max_rate.IsFinite())
-                encoder->SetMaxBitrate(config.encoder.fake.max_rate.kbps());
+              fake_encoders_.push_back(encoder.get());
+              if (config_.encoder.fake.max_rate.IsFinite())
+                encoder->SetMaxBitrate(config_.encoder.fake.max_rate.kbps());
               return encoder;
             });
       } else {
@@ -250,17 +258,31 @@ void SendVideoStream::Start() {
   video_capturer_->Start();
 }
 
+void SendVideoStream::UpdateConfig(
+    std::function<void(VideoStreamConfig*)> modifier) {
+  rtc::CritScope cs(&crit_);
+  VideoStreamConfig prior_config = config_;
+  modifier(&config_);
+  if (prior_config.encoder.fake.max_rate != config_.encoder.fake.max_rate) {
+    for (auto* encoder : fake_encoders_) {
+      encoder->SetMaxBitrate(config_.encoder.fake.max_rate.kbps());
+    }
+  }
+  // TODO(srte): Add more conditions that should cause reconfiguration.
+  if (prior_config.encoder.max_framerate != config_.encoder.max_framerate) {
+    VideoEncoderConfig encoder_config = CreateVideoEncoderConfig(config_);
+    send_stream_->ReconfigureVideoEncoder(std::move(encoder_config));
+  }
+  if (prior_config.source.framerate != config_.source.framerate) {
+    SetCaptureFramerate(config_.source.framerate);
+  }
+}
+
 void SendVideoStream::SetCaptureFramerate(int framerate) {
   RTC_CHECK(frame_generator_)
       << "Framerate change only implemented for generators";
   frame_generator_->ChangeFramerate(framerate);
-}
 
-void SendVideoStream::SetMaxFramerate(absl::optional<int> max_framerate) {
-  VideoEncoderConfig encoder_config = CreateVideoEncoderConfig(config_);
-  RTC_DCHECK_EQ(encoder_config.simulcast_layers.size(), 1);
-  encoder_config.simulcast_layers[0].max_framerate = max_framerate.value_or(-1);
-  send_stream_->ReconfigureVideoEncoder(std::move(encoder_config));
 }
 
 VideoSendStream::Stats SendVideoStream::GetStats() const {
@@ -290,9 +312,7 @@ ReceiveVideoStream::ReceiveVideoStream(CallClient* receiver,
                                        SendVideoStream* send_stream,
                                        size_t chosen_stream,
                                        Transport* feedback_transport)
-    : receiver_(receiver),
-      config_(config),
-      decoder_factory_(absl::make_unique<InternalDecoderFactory>()) {
+    : receiver_(receiver), config_(config) {
   renderer_ = absl::make_unique<FakeVideoRenderer>();
   VideoReceiveStream::Config recv_config(feedback_transport);
   recv_config.rtp.remb = !config.stream.packet_feedback;
@@ -317,6 +337,13 @@ ReceiveVideoStream::ReceiveVideoStream(CallClient* receiver,
   VideoReceiveStream::Decoder decoder =
       CreateMatchingDecoder(CodecTypeToPayloadType(config.encoder.codec),
                             CodecTypeToPayloadString(config.encoder.codec));
+  if (config.encoder.codec ==
+      VideoStreamConfig::Encoder::Codec::kVideoCodecGeneric) {
+    decoder_factory_ = absl::make_unique<FunctionVideoDecoderFactory>(
+        []() { return absl::make_unique<FakeDecoder>(); });
+  } else {
+    decoder_factory_ = absl::make_unique<InternalDecoderFactory>();
+  }
   decoder.decoder_factory = decoder_factory_.get();
   recv_config.decoders.push_back(decoder);
 

test/scenario/video_stream.h

@@ -14,6 +14,7 @@
 #include <vector>
 
 #include "rtc_base/constructormagic.h"
+#include "test/fake_encoder.h"
 #include "test/frame_generator_capturer.h"
 #include "test/scenario/call_client.h"
 #include "test/scenario/column_printer.h"
@@ -30,10 +31,10 @@ class SendVideoStream {
   RTC_DISALLOW_COPY_AND_ASSIGN(SendVideoStream);
   ~SendVideoStream();
   void SetCaptureFramerate(int framerate);
-  void SetMaxFramerate(absl::optional<int> max_framerate);
   VideoSendStream::Stats GetStats() const;
   ColumnPrinter StatsPrinter();
   void Start();
+  void UpdateConfig(std::function<void(VideoStreamConfig*)> modifier);
 
  private:
   friend class Scenario;
@@ -44,12 +45,14 @@ class SendVideoStream {
                   VideoStreamConfig config,
                   Transport* send_transport);
 
+  rtc::CriticalSection crit_;
   std::vector<uint32_t> ssrcs_;
   std::vector<uint32_t> rtx_ssrcs_;
   VideoSendStream* send_stream_ = nullptr;
   CallClient* const sender_;
-  const VideoStreamConfig config_;
+  VideoStreamConfig config_ RTC_GUARDED_BY(crit_);
   std::unique_ptr<VideoEncoderFactory> encoder_factory_;
+  std::vector<test::FakeEncoder*> fake_encoders_ RTC_GUARDED_BY(crit_);
   std::unique_ptr<VideoBitrateAllocatorFactory> bitrate_allocator_factory_;
   std::unique_ptr<TestVideoCapturer> video_capturer_;
   FrameGeneratorCapturer* frame_generator_ = nullptr;