diff --git a/webrtc/media/engine/webrtcvideoengine.cc b/webrtc/media/engine/webrtcvideoengine.cc
index 25afbb6..54d7103 100644
--- a/webrtc/media/engine/webrtcvideoengine.cc
+++ b/webrtc/media/engine/webrtcvideoengine.cc
@@ -286,69 +286,6 @@
   }
   return 1;
 }
-
-class EncoderStreamFactory
-    : public webrtc::VideoEncoderConfig::VideoStreamFactoryInterface {
- public:
-  EncoderStreamFactory(std::string codec_name,
-                       int max_qp,
-                       int max_framerate,
-                       bool is_screencast,
-                       bool conference_mode)
-      : codec_name_(codec_name),
-        max_qp_(max_qp),
-        max_framerate_(max_framerate),
-        is_screencast_(is_screencast),
-        conference_mode_(conference_mode) {}
-
- private:
-  std::vector<webrtc::VideoStream> CreateEncoderStreams(
-      int width,
-      int height,
-      const webrtc::VideoEncoderConfig& encoder_config) override {
-    if (is_screencast_ &&
-        (!conference_mode_ || !cricket::UseSimulcastScreenshare())) {
-      RTC_DCHECK_EQ(1, encoder_config.number_of_streams);
-    }
-    if (encoder_config.number_of_streams > 1 ||
-        (CodecNamesEq(codec_name_, kVp8CodecName) && is_screencast_ &&
-         conference_mode_)) {
-      return GetSimulcastConfig(encoder_config.number_of_streams, width, height,
-                                encoder_config.max_bitrate_bps, max_qp_,
-                                max_framerate_, is_screencast_);
-    }
-
-    // For unset max bitrates set default bitrate for non-simulcast.
-    int max_bitrate_bps =
-        (encoder_config.max_bitrate_bps > 0)
-            ? encoder_config.max_bitrate_bps
-            : GetMaxDefaultVideoBitrateKbps(width, height) * 1000;
-
-    webrtc::VideoStream stream;
-    stream.width = width;
-    stream.height = height;
-    stream.max_framerate = max_framerate_;
-    stream.min_bitrate_bps = kMinVideoBitrateKbps * 1000;
-    stream.target_bitrate_bps = stream.max_bitrate_bps = max_bitrate_bps;
-    stream.max_qp = max_qp_;
-
-    if (CodecNamesEq(codec_name_, kVp9CodecName) && !is_screencast_) {
-      stream.temporal_layer_thresholds_bps.resize(
-          GetDefaultVp9TemporalLayers() - 1);
-    }
-
-    std::vector<webrtc::VideoStream> streams;
-    streams.push_back(stream);
-    return streams;
-  }
-
-  const std::string codec_name_;
-  const int max_qp_;
-  const int max_framerate_;
-  const bool is_screencast_;
-  const bool conference_mode_;
-};
-
 }  // namespace
 
 // Constants defined in webrtc/media/engine/constants.h
@@ -2676,4 +2613,55 @@
   return video_codecs;
 }
 
+EncoderStreamFactory::EncoderStreamFactory(std::string codec_name,
+                                           int max_qp,
+                                           int max_framerate,
+                                           bool is_screencast,
+                                           bool conference_mode)
+    : codec_name_(codec_name),
+      max_qp_(max_qp),
+      max_framerate_(max_framerate),
+      is_screencast_(is_screencast),
+      conference_mode_(conference_mode) {}
+
+std::vector<webrtc::VideoStream> EncoderStreamFactory::CreateEncoderStreams(
+    int width,
+    int height,
+    const webrtc::VideoEncoderConfig& encoder_config) {
+  if (is_screencast_ &&
+      (!conference_mode_ || !cricket::UseSimulcastScreenshare())) {
+    RTC_DCHECK_EQ(1, encoder_config.number_of_streams);
+  }
+  if (encoder_config.number_of_streams > 1 ||
+      (CodecNamesEq(codec_name_, kVp8CodecName) && is_screencast_ &&
+       conference_mode_)) {
+    return GetSimulcastConfig(encoder_config.number_of_streams, width, height,
+                              encoder_config.max_bitrate_bps, max_qp_,
+                              max_framerate_, is_screencast_);
+  }
+
+  // For unset max bitrates set default bitrate for non-simulcast.
+  int max_bitrate_bps =
+      (encoder_config.max_bitrate_bps > 0)
+          ? encoder_config.max_bitrate_bps
+          : GetMaxDefaultVideoBitrateKbps(width, height) * 1000;
+
+  webrtc::VideoStream stream;
+  stream.width = width;
+  stream.height = height;
+  stream.max_framerate = max_framerate_;
+  stream.min_bitrate_bps = kMinVideoBitrateKbps * 1000;
+  stream.target_bitrate_bps = stream.max_bitrate_bps = max_bitrate_bps;
+  stream.max_qp = max_qp_;
+
+  if (CodecNamesEq(codec_name_, kVp9CodecName) && !is_screencast_) {
+    stream.temporal_layer_thresholds_bps.resize(GetDefaultVp9TemporalLayers() -
+                                                1);
+  }
+
+  std::vector<webrtc::VideoStream> streams;
+  streams.push_back(stream);
+  return streams;
+}
+
 }  // namespace cricket
diff --git a/webrtc/media/engine/webrtcvideoengine.h b/webrtc/media/engine/webrtcvideoengine.h
index 8928b41..c51aa69 100644
--- a/webrtc/media/engine/webrtcvideoengine.h
+++ b/webrtc/media/engine/webrtcvideoengine.h
@@ -525,6 +525,28 @@
   int64_t last_stats_log_ms_;
 };
 
+class EncoderStreamFactory
+    : public webrtc::VideoEncoderConfig::VideoStreamFactoryInterface {
+ public:
+  EncoderStreamFactory(std::string codec_name,
+                       int max_qp,
+                       int max_framerate,
+                       bool is_screencast,
+                       bool conference_mode);
+
+ private:
+  std::vector<webrtc::VideoStream> CreateEncoderStreams(
+      int width,
+      int height,
+      const webrtc::VideoEncoderConfig& encoder_config) override;
+
+  const std::string codec_name_;
+  const int max_qp_;
+  const int max_framerate_;
+  const bool is_screencast_;
+  const bool conference_mode_;
+};
+
 }  // namespace cricket
 
 #endif  // WEBRTC_MEDIA_ENGINE_WEBRTCVIDEOENGINE_H_
diff --git a/webrtc/video/full_stack_tests.cc b/webrtc/video/full_stack_tests.cc
index 1e3b279..8299771 100644
--- a/webrtc/video/full_stack_tests.cc
+++ b/webrtc/video/full_stack_tests.cc
@@ -331,7 +331,7 @@
   std::vector<VideoStream> streams = {
       DefaultVideoStream(screenshare_params_low),
       DefaultVideoStream(screenshare_params_high)};
-  screenshare.ss = {streams, 1, 1, 0};
+  screenshare.ss = {streams, 1, 1, 0, std::vector<SpatialLayer>(), false};
   RunTest(screenshare);
 }
 
@@ -423,7 +423,8 @@
   screenshare.analyzer = {"screenshare_slides_vp9_2sl", 0.0, 0.0,
                           kFullStackTestDurationSecs};
   screenshare.logs = false;
-  screenshare.ss = {std::vector<VideoStream>(), 0, 2, 1};
+  screenshare.ss = {std::vector<VideoStream>(),  0,    2, 1,
+                    std::vector<SpatialLayer>(), false};
   RunTest(screenshare);
 }
 
@@ -434,7 +435,8 @@
   simulcast.analyzer = {"vp9svc_3sl_high", 0.0, 0.0,
                         kFullStackTestDurationSecs};
   simulcast.logs = false;
-  simulcast.ss = {std::vector<VideoStream>(), 0, 3, 2};
+  simulcast.ss = {std::vector<VideoStream>(),  0,    3, 2,
+                  std::vector<SpatialLayer>(), false};
   RunTest(simulcast);
 }
 
@@ -445,7 +447,8 @@
   simulcast.analyzer = {"vp9svc_3sl_medium", 0.0, 0.0,
                         kFullStackTestDurationSecs};
   simulcast.logs = false;
-  simulcast.ss = {std::vector<VideoStream>(), 0, 3, 1};
+  simulcast.ss = {std::vector<VideoStream>(),  0,    3, 1,
+                  std::vector<SpatialLayer>(), false};
   RunTest(simulcast);
 }
 
@@ -455,11 +458,38 @@
   simulcast.video = kSvcVp9Video;
   simulcast.analyzer = {"vp9svc_3sl_low", 0.0, 0.0, kFullStackTestDurationSecs};
   simulcast.logs = false;
-  simulcast.ss = {std::vector<VideoStream>(), 0, 3, 0};
+  simulcast.ss = {std::vector<VideoStream>(),  0,    3, 0,
+                  std::vector<SpatialLayer>(), false};
   RunTest(simulcast);
 }
 #endif  // !defined(RTC_DISABLE_VP9)
 
+// Android bots can't handle FullHD, so disable the test.
+#if defined(WEBRTC_ANDROID)
+#define MAYBE_SimulcastFullHdOveruse DISABLED_SimulcastFullHdOveruse
+#else
+#define MAYBE_SimulcastFullHdOveruse SimulcastFullHdOveruse
+#endif
+
+TEST_F(FullStackTest, MAYBE_SimulcastFullHdOveruse) {
+  VideoQualityTest::Params simulcast;
+  simulcast.call.send_side_bwe = true;
+  simulcast.video = {true,    1920, 1080, 30, 800000, 2500000,
+                     2500000, false,        "VP8",        3,  2,      400000,
+                     false,   false,        "",           "Generator"};
+  simulcast.analyzer = {"simulcast_HD_high", 0.0, 0.0,
+                        kFullStackTestDurationSecs};
+  simulcast.pipe.loss_percent = 0;
+  simulcast.pipe.queue_delay_ms = 100;
+  std::vector<VideoStream> streams = {DefaultVideoStream(simulcast),
+                                      DefaultVideoStream(simulcast),
+                                      DefaultVideoStream(simulcast)};
+  simulcast.ss = {streams, 2, 1, 0, std::vector<SpatialLayer>(), true};
+  webrtc::test::ScopedFieldTrials override_trials(
+      "WebRTC-ForceSimulatedOveruseIntervalMs/1000-50000-300/");
+  RunTest(simulcast);
+}
+
 TEST_F(FullStackTest, SimulcastVP8_3SL_High) {
   VideoQualityTest::Params simulcast;
   simulcast.call.send_side_bwe = true;
@@ -478,7 +508,7 @@
   std::vector<VideoStream> streams = {DefaultVideoStream(video_params_low),
                                       DefaultVideoStream(video_params_medium),
                                       DefaultVideoStream(video_params_high)};
-  simulcast.ss = {streams, 2, 1, 0};
+  simulcast.ss = {streams, 2, 1, 0, std::vector<SpatialLayer>(), false};
   RunTest(simulcast);
 }
 
@@ -500,7 +530,7 @@
   std::vector<VideoStream> streams = {DefaultVideoStream(video_params_low),
                                       DefaultVideoStream(video_params_medium),
                                       DefaultVideoStream(video_params_high)};
-  simulcast.ss = {streams, 1, 1, 0};
+  simulcast.ss = {streams, 1, 1, 0, std::vector<SpatialLayer>(), false};
   RunTest(simulcast);
 }
 
@@ -522,7 +552,7 @@
   std::vector<VideoStream> streams = {DefaultVideoStream(video_params_low),
                                       DefaultVideoStream(video_params_medium),
                                       DefaultVideoStream(video_params_high)};
-  simulcast.ss = {streams, 0, 1, 0};
+  simulcast.ss = {streams, 0, 1, 0, std::vector<SpatialLayer>(), false};
   RunTest(simulcast);
 }
 
@@ -545,7 +575,7 @@
                                       DefaultVideoStream(video_params_medium),
                                       DefaultVideoStream(video_params_high)};
   large_room.num_thumbnails = 5;
-  large_room.ss = {streams, 2, 1, 0};
+  large_room.ss = {streams, 2, 1, 0, std::vector<SpatialLayer>(), false};
   RunTest(large_room);
 }
 
@@ -578,7 +608,7 @@
                                       DefaultVideoStream(video_params_medium),
                                       DefaultVideoStream(video_params_high)};
   large_room.num_thumbnails = 15;
-  large_room.ss = {streams, 2, 1, 0};
+  large_room.ss = {streams, 2, 1, 0, std::vector<SpatialLayer>(), false};
   RunTest(large_room);
 }
 
@@ -601,7 +631,7 @@
                                       DefaultVideoStream(video_params_medium),
                                       DefaultVideoStream(video_params_high)};
   large_room.num_thumbnails = 50;
-  large_room.ss = {streams, 2, 1, 0};
+  large_room.ss = {streams, 2, 1, 0, std::vector<SpatialLayer>(), false};
   RunTest(large_room);
 }
 
diff --git a/webrtc/video/video_quality_test.cc b/webrtc/video/video_quality_test.cc
index 0ccc6b8..d19ecbe 100644
--- a/webrtc/video/video_quality_test.cc
+++ b/webrtc/video/video_quality_test.cc
@@ -148,12 +148,13 @@
                 size_t selected_stream,
                 int selected_sl,
                 int selected_tl,
-                bool is_quick_test_enabled)
+                bool is_quick_test_enabled,
+                Clock* clock)
       : transport_(transport),
         receiver_(nullptr),
         send_stream_(nullptr),
         receive_stream_(nullptr),
-        captured_frame_forwarder_(this),
+        captured_frame_forwarder_(this, clock),
         test_label_(test_label),
         graph_data_output_file_(graph_data_output_file),
         graph_title_(graph_title),
@@ -219,6 +220,13 @@
 
   virtual void SetReceiver(PacketReceiver* receiver) { receiver_ = receiver; }
 
+  void SetSource(test::VideoCapturer* video_capturer, bool respect_sink_wants) {
+    if (respect_sink_wants)
+      captured_frame_forwarder_.SetSource(video_capturer);
+    rtc::VideoSinkWants wants;
+    video_capturer->AddOrUpdateSink(InputInterface(), wants);
+  }
+
   void SetSendStream(VideoSendStream* stream) {
     rtc::CritScope lock(&crit_);
     RTC_DCHECK(!send_stream_);
@@ -782,7 +790,7 @@
     // Perform expensive psnr and ssim calculations while not holding lock.
     double psnr = -1.0;
     double ssim = -1.0;
-    if (comparison.reference) {
+    if (comparison.reference && !comparison.dropped) {
       psnr = I420PSNR(&*comparison.reference, &*comparison.render);
       ssim = I420SSIM(&*comparison.reference, &*comparison.render);
     }
@@ -901,8 +909,15 @@
   class CapturedFrameForwarder : public rtc::VideoSinkInterface<VideoFrame>,
                                  public rtc::VideoSourceInterface<VideoFrame> {
    public:
-    explicit CapturedFrameForwarder(VideoAnalyzer* analyzer)
-        : analyzer_(analyzer), send_stream_input_(nullptr) {}
+    explicit CapturedFrameForwarder(VideoAnalyzer* analyzer, Clock* clock)
+        : analyzer_(analyzer),
+          send_stream_input_(nullptr),
+          video_capturer_(nullptr),
+          clock_(clock) {}
+
+    void SetSource(test::VideoCapturer* video_capturer) {
+      video_capturer_ = video_capturer;
+    }
 
    private:
     void OnFrame(const VideoFrame& video_frame) override {
@@ -910,8 +925,8 @@
       // Frames from the capturer does not have a rtp timestamp.
       // Create one so it can be used for comparison.
       RTC_DCHECK_EQ(0, video_frame.timestamp());
-      if (copy.ntp_time_ms() == 0)
-        copy.set_ntp_time_ms(rtc::TimeMillis());
+      if (video_frame.ntp_time_ms() == 0)
+        copy.set_ntp_time_ms(clock_->CurrentNtpInMilliseconds());
       copy.set_timestamp(copy.ntp_time_ms() * 90);
       analyzer_->AddCapturedFrameForComparison(copy);
       rtc::CritScope lock(&crit_);
@@ -925,6 +940,9 @@
       rtc::CritScope lock(&crit_);
       RTC_DCHECK(!send_stream_input_ || send_stream_input_ == sink);
       send_stream_input_ = sink;
+      if (video_capturer_) {
+        video_capturer_->AddOrUpdateSink(this, wants);
+      }
     }
 
     // Called by |send_stream_| when |send_stream_.SetSource()| is called.
@@ -937,6 +955,8 @@
     VideoAnalyzer* const analyzer_;
     rtc::CriticalSection crit_;
     rtc::VideoSinkInterface<VideoFrame>* send_stream_input_ GUARDED_BY(crit_);
+    test::VideoCapturer* video_capturer_;
+    Clock* clock_;
   };
 
   void AddCapturedFrameForComparison(const VideoFrame& video_frame) {
@@ -1238,6 +1258,7 @@
     params->ss.streams.push_back(stream);
   }
   params->ss.selected_stream = selected_stream;
+  params->ss.infer_streams = false;
 
   params->ss.num_spatial_layers = num_spatial_layers ? num_spatial_layers : 1;
   params->ss.selected_sl = selected_sl;
@@ -1319,8 +1340,15 @@
     video_encoder_config_.max_bitrate_bps +=
         params_.ss.streams[i].max_bitrate_bps;
   }
-  video_encoder_config_.video_stream_factory =
-      new rtc::RefCountedObject<VideoStreamFactory>(params_.ss.streams);
+  if (params_.ss.infer_streams) {
+    video_encoder_config_.video_stream_factory =
+        new rtc::RefCountedObject<cricket::EncoderStreamFactory>(
+            params_.video.codec, params_.ss.streams[0].max_qp,
+            params_.video.fps, params_.screenshare.enabled, true);
+  } else {
+    video_encoder_config_.video_stream_factory =
+        new rtc::RefCountedObject<VideoStreamFactory>(params_.ss.streams);
+  }
 
   video_encoder_config_.spatial_layers = params_.ss.spatial_layers;
 
@@ -1423,9 +1451,15 @@
         params_.video.suspend_below_min_bitrate;
     thumbnail_encoder_config.number_of_streams = 1;
     thumbnail_encoder_config.max_bitrate_bps = 50000;
-    thumbnail_encoder_config.video_stream_factory =
-        new rtc::RefCountedObject<VideoStreamFactory>(
-            std::vector<webrtc::VideoStream>{DefaultThumbnailStream()});
+    if (params_.ss.infer_streams) {
+      thumbnail_encoder_config.video_stream_factory =
+          new rtc::RefCountedObject<VideoStreamFactory>(params_.ss.streams);
+    } else {
+      thumbnail_encoder_config.video_stream_factory =
+          new rtc::RefCountedObject<cricket::EncoderStreamFactory>(
+              params_.video.codec, params_.ss.streams[0].max_qp,
+              params_.video.fps, params_.screenshare.enabled, true);
+    }
     thumbnail_encoder_config.spatial_layers = params_.ss.spatial_layers;
 
     VideoReceiveStream::Config thumbnail_receive_config(send_transport);
@@ -1565,7 +1599,11 @@
     EXPECT_TRUE(frame_generator_capturer->Init());
     video_capturer_.reset(frame_generator_capturer);
   } else {
-    if (params_.video.clip_name.empty()) {
+    if (params_.video.clip_name == "Generator") {
+      video_capturer_.reset(test::FrameGeneratorCapturer::Create(
+          static_cast<int>(params_.video.width),
+          static_cast<int>(params_.video.height), params_.video.fps, clock_));
+    } else if (params_.video.clip_name.empty()) {
       video_capturer_.reset(test::VcmCapturer::Create(
           params_.video.width, params_.video.height, params_.video.fps,
           params_.video.capture_device_index));
@@ -1631,7 +1669,7 @@
       kVideoSendSsrcs[params_.ss.selected_stream],
       kSendRtxSsrcs[params_.ss.selected_stream],
       static_cast<size_t>(params_.ss.selected_stream), params.ss.selected_sl,
-      params_.video.selected_tl, is_quick_test_enabled);
+      params_.video.selected_tl, is_quick_test_enabled, clock_);
   analyzer.SetReceiver(receiver_call_->Receiver());
   send_transport.SetReceiver(&analyzer);
   recv_transport.SetReceiver(sender_call_->Receiver());
@@ -1662,8 +1700,7 @@
 
   CreateCapturer();
 
-  rtc::VideoSinkWants wants;
-  video_capturer_->AddOrUpdateSink(analyzer.InputInterface(), wants);
+  analyzer.SetSource(video_capturer_.get(), params_.ss.infer_streams);
 
   StartEncodedFrameLogs(video_send_stream_);
   StartEncodedFrameLogs(video_receive_streams_[0]);
diff --git a/webrtc/video/video_quality_test.h b/webrtc/video/video_quality_test.h
index 5cf54bd..d2fa2ed 100644
--- a/webrtc/video/video_quality_test.h
+++ b/webrtc/video/video_quality_test.h
@@ -51,7 +51,7 @@
       bool ulpfec;
       bool flexfec;
       std::string encoded_frame_base_path;
-      std::string clip_name;
+      std::string clip_name;  // "Generator" to generate frames instead.
       size_t capture_device_index;
     } video;
     struct Audio {
@@ -82,6 +82,8 @@
       int selected_sl;
       // If empty, bitrates are generated in VP9Impl automatically.
       std::vector<SpatialLayer> spatial_layers;
+      // If set, default parameters will be used instead of |streams|.
+      bool infer_streams;
     } ss;
     int num_thumbnails;
   };
diff --git a/webrtc/video/vie_encoder.cc b/webrtc/video/vie_encoder.cc
index d82e4fc..3308961 100644
--- a/webrtc/video/vie_encoder.cc
+++ b/webrtc/video/vie_encoder.cc
@@ -15,6 +15,7 @@
 #include <numeric>
 #include <utility>
 
+#include "webrtc/api/video/i420_buffer.h"
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/location.h"
@@ -575,6 +576,20 @@
       encoder_config_.video_stream_factory->CreateEncoderStreams(
           last_frame_info_->width, last_frame_info_->height, encoder_config_);
 
+  // TODO(ilnik): If configured resolution is significantly less than provided,
+  // e.g. because there are not enough SSRCs for all simulcast streams,
+  // signal new resolutions via SinkWants to video source.
+
+  // Stream dimensions may be not equal to given because of a simulcast
+  // restrictions.
+  int highest_stream_width = static_cast<int>(streams.back().width);
+  int highest_stream_height = static_cast<int>(streams.back().height);
+  // Dimension may be reduced to be, e.g. divisible by 4.
+  RTC_CHECK_GE(last_frame_info_->width, highest_stream_width);
+  RTC_CHECK_GE(last_frame_info_->height, highest_stream_height);
+  crop_width_ = last_frame_info_->width - highest_stream_width;
+  crop_height_ = last_frame_info_->height - highest_stream_height;
+
   VideoCodec codec;
   if (!VideoCodecInitializer::SetupCodec(encoder_config_, settings_, streams,
                                          nack_enabled_, &codec,
@@ -770,12 +785,35 @@
   }
   TraceFrameDropEnd();
 
+  VideoFrame out_frame(video_frame);
+  // Crop frame if needed.
+  if (crop_width_ > 0 || crop_height_ > 0) {
+    int cropped_width = video_frame.width() - crop_width_;
+    int cropped_height = video_frame.height() - crop_height_;
+    rtc::scoped_refptr<I420Buffer> cropped_buffer =
+        I420Buffer::Create(cropped_width, cropped_height);
+    // TODO(ilnik): Remove scaling if cropping is too big, as it should never
+    // happen after SinkWants signaled correctly from ReconfigureEncoder.
+    if (crop_width_ < 4 && crop_height_ < 4) {
+      cropped_buffer->CropAndScaleFrom(
+          *video_frame.video_frame_buffer()->ToI420(), crop_width_ / 2,
+          crop_height_ / 2, cropped_width, cropped_height);
+    } else {
+      cropped_buffer->ScaleFrom(
+          *video_frame.video_frame_buffer()->ToI420().get());
+    }
+    out_frame =
+        VideoFrame(cropped_buffer, video_frame.timestamp(),
+                   video_frame.render_time_ms(), video_frame.rotation());
+    out_frame.set_ntp_time_ms(video_frame.ntp_time_ms());
+  }
+
   TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", video_frame.render_time_ms(),
                           "Encode");
 
-  overuse_detector_->FrameCaptured(video_frame, time_when_posted_us);
+  overuse_detector_->FrameCaptured(out_frame, time_when_posted_us);
 
-  video_sender_.AddVideoFrame(video_frame, nullptr);
+  video_sender_.AddVideoFrame(out_frame, nullptr);
 }
 
 void ViEEncoder::SendKeyFrame() {
diff --git a/webrtc/video/vie_encoder.h b/webrtc/video/vie_encoder.h
index 77a6bc4..91c6ca4 100644
--- a/webrtc/video/vie_encoder.h
+++ b/webrtc/video/vie_encoder.h
@@ -257,6 +257,8 @@
   // encoder on the next frame.
   bool pending_encoder_reconfiguration_ ACCESS_ON(&encoder_queue_);
   rtc::Optional<VideoFrameInfo> last_frame_info_ ACCESS_ON(&encoder_queue_);
+  int crop_width_ ACCESS_ON(&encoder_queue_);
+  int crop_height_ ACCESS_ON(&encoder_queue_);
   uint32_t encoder_start_bitrate_bps_ ACCESS_ON(&encoder_queue_);
   size_t max_data_payload_length_ ACCESS_ON(&encoder_queue_);
   bool nack_enabled_ ACCESS_ON(&encoder_queue_);
diff --git a/webrtc/video/vie_encoder_unittest.cc b/webrtc/video/vie_encoder_unittest.cc
index b143e4d..976cf47 100644
--- a/webrtc/video/vie_encoder_unittest.cc
+++ b/webrtc/video/vie_encoder_unittest.cc
@@ -166,6 +166,7 @@
   const int framerate_;
 };
 
+
 class AdaptingFrameForwarder : public test::FrameForwarder {
  public:
   AdaptingFrameForwarder() : adaptation_enabled_(false) {}
@@ -2944,4 +2945,71 @@
   vie_encoder_->Stop();
 }
 
+TEST_F(ViEEncoderTest, AcceptsFullHdAdaptedDownSimulcastFrames) {
+  // Simulates simulcast behavior and makes highest stream resolutions divisible
+  // by 4.
+  class CroppingVideoStreamFactory
+      : public VideoEncoderConfig::VideoStreamFactoryInterface {
+   public:
+    explicit CroppingVideoStreamFactory(size_t num_temporal_layers,
+                                        int framerate)
+        : num_temporal_layers_(num_temporal_layers), framerate_(framerate) {
+      EXPECT_GT(num_temporal_layers, 0u);
+      EXPECT_GT(framerate, 0);
+    }
+
+   private:
+    std::vector<VideoStream> CreateEncoderStreams(
+        int width,
+        int height,
+        const VideoEncoderConfig& encoder_config) override {
+      std::vector<VideoStream> streams =
+          test::CreateVideoStreams(width - width % 4, height - height % 4,
+                                   encoder_config);
+      for (VideoStream& stream : streams) {
+        stream.temporal_layer_thresholds_bps.resize(num_temporal_layers_ - 1);
+        stream.max_framerate = framerate_;
+      }
+      return streams;
+    }
+
+    const size_t num_temporal_layers_;
+    const int framerate_;
+  };
+
+  const int kFrameWidth = 1920;
+  const int kFrameHeight = 1080;
+  // 3/4 of 1920.
+  const int kAdaptedFrameWidth = 1440;
+  // 3/4 of 1080 rounded down to multiple of 4.
+  const int kAdaptedFrameHeight = 808;
+  const int kFramerate = 24;
+
+  vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
+  // Trigger reconfigure encoder (without resetting the entire instance).
+  VideoEncoderConfig video_encoder_config;
+  video_encoder_config.max_bitrate_bps = kTargetBitrateBps;
+  video_encoder_config.number_of_streams = 1;
+  video_encoder_config.video_stream_factory =
+      new rtc::RefCountedObject<CroppingVideoStreamFactory>(1, kFramerate);
+  vie_encoder_->ConfigureEncoder(std::move(video_encoder_config),
+                                   kMaxPayloadLength, false);
+  vie_encoder_->WaitUntilTaskQueueIsIdle();
+
+  video_source_.set_adaptation_enabled(true);
+
+  video_source_.IncomingCapturedFrame(
+      CreateFrame(1, kFrameWidth, kFrameHeight));
+  sink_.WaitForEncodedFrame(kFrameWidth, kFrameHeight);
+
+  // Trigger CPU overuse, downscale by 3/4.
+  vie_encoder_->TriggerCpuOveruse();
+  video_source_.IncomingCapturedFrame(
+      CreateFrame(2, kFrameWidth, kFrameHeight));
+  sink_.WaitForEncodedFrame(kAdaptedFrameWidth, kAdaptedFrameHeight);
+
+  vie_encoder_->Stop();
+}
+
+
 }  // namespace webrtc