diff --git a/modules/video_coding/utility/quality_scaler.cc b/modules/video_coding/utility/quality_scaler.cc
index 42c40c5..d31b2cd 100644
--- a/modules/video_coding/utility/quality_scaler.cc
+++ b/modules/video_coding/utility/quality_scaler.cc
@@ -96,7 +96,8 @@
                                 .value_or(kSamplePeriodScaleFactor)),
       scale_factor_(
           QualityScalerSettings::ParseFromFieldTrials().ScaleFactor()),
-      last_adapted_(false) {
+      adapt_called_(false),
+      adapt_failed_(false) {
   RTC_DCHECK_RUN_ON(&task_checker_);
   if (experiment_enabled_) {
     config_ = QualityScalingExperiment::GetConfig();
@@ -127,8 +128,12 @@
     // Use half the interval while waiting for enough frames.
     return sampling_period_ms_ / 2;
   }
-  if (scale_factor_ && !last_adapted_) {
-    // Last check did not result in a AdaptDown/Up, possibly reduce interval.
+  if (adapt_failed_) {
+    // Check shortly again.
+    return sampling_period_ms_ / 8;
+  }
+  if (scale_factor_ && !adapt_called_) {
+    // Last CheckQp did not call AdaptDown/Up, possibly reduce interval.
     return sampling_period_ms_ * scale_factor_.value();
   }
   return sampling_period_ms_ * initial_scale_factor_;
@@ -165,7 +170,8 @@
   RTC_DCHECK_RUN_ON(&task_checker_);
   // Should be set through InitEncode -> Should be set by now.
   RTC_DCHECK_GE(thresholds_.low, 0);
-  last_adapted_ = false;
+  adapt_failed_ = false;
+  adapt_called_ = false;
 
   // If we have not observed at least this many frames we can't make a good
   // scaling decision.
@@ -215,18 +221,24 @@
   RTC_DCHECK_RUN_ON(&task_checker_);
   ClearSamples();
   observer_->AdaptUp(AdaptationObserverInterface::AdaptReason::kQuality);
-  last_adapted_ = true;
+  adapt_called_ = true;
 }
 
 void QualityScaler::ReportQpHigh() {
   RTC_DCHECK_RUN_ON(&task_checker_);
-  ClearSamples();
-  observer_->AdaptDown(AdaptationObserverInterface::AdaptReason::kQuality);
+
+  if (observer_->AdaptDown(
+          AdaptationObserverInterface::AdaptReason::kQuality)) {
+    ClearSamples();
+  } else {
+    adapt_failed_ = true;
+  }
+
   // If we've scaled down, wait longer before scaling up again.
   if (fast_rampup_) {
     fast_rampup_ = false;
   }
-  last_adapted_ = true;
+  adapt_called_ = true;
 }
 
 void QualityScaler::ClearSamples() {
diff --git a/modules/video_coding/utility/quality_scaler.h b/modules/video_coding/utility/quality_scaler.h
index 32e522b..9a1b384 100644
--- a/modules/video_coding/utility/quality_scaler.h
+++ b/modules/video_coding/utility/quality_scaler.h
@@ -37,7 +37,9 @@
   // Called to signal that we can handle larger or more frequent frames.
   virtual void AdaptUp(AdaptReason reason) = 0;
   // Called to signal that the source should reduce the resolution or framerate.
-  virtual void AdaptDown(AdaptReason reason) = 0;
+  // Returns false if a downgrade was requested but the request did not result
+  // in a new limiting resolution or fps.
+  virtual bool AdaptDown(AdaptReason reason) = 0;
 
  protected:
   virtual ~AdaptationObserverInterface() {}
@@ -101,7 +103,8 @@
   const size_t min_frames_needed_;
   const double initial_scale_factor_;
   const absl::optional<double> scale_factor_;
-  bool last_adapted_ RTC_GUARDED_BY(&task_checker_);
+  bool adapt_called_ RTC_GUARDED_BY(&task_checker_);
+  bool adapt_failed_ RTC_GUARDED_BY(&task_checker_);
 };
 }  // namespace webrtc
 
diff --git a/modules/video_coding/utility/quality_scaler_unittest.cc b/modules/video_coding/utility/quality_scaler_unittest.cc
index 99eaed1..012ef72 100644
--- a/modules/video_coding/utility/quality_scaler_unittest.cc
+++ b/modules/video_coding/utility/quality_scaler_unittest.cc
@@ -36,9 +36,10 @@
     adapt_up_events_++;
     event.Set();
   }
-  void AdaptDown(AdaptReason r) override {
+  bool AdaptDown(AdaptReason r) override {
     adapt_down_events_++;
     event.Set();
+    return true;
   }
 
   rtc::Event event;
diff --git a/rtc_base/experiments/balanced_degradation_settings.cc b/rtc_base/experiments/balanced_degradation_settings.cc
index 3dda134..8306027 100644
--- a/rtc_base/experiments/balanced_degradation_settings.cc
+++ b/rtc_base/experiments/balanced_degradation_settings.cc
@@ -24,9 +24,30 @@
 constexpr int kMaxFps = 100;  // 100 means unlimited fps.
 
 std::vector<BalancedDegradationSettings::Config> DefaultConfigs() {
-  return {{320 * 240, 7, 0, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}},
-          {480 * 270, 10, 0, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}},
-          {640 * 480, 15, 0, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}}};
+  return {{320 * 240,
+           7,
+           0,
+           BalancedDegradationSettings::kNoFpsDiff,
+           {0, 0, 0},
+           {0, 0, 0},
+           {0, 0, 0},
+           {0, 0, 0}},
+          {480 * 270,
+           10,
+           0,
+           BalancedDegradationSettings::kNoFpsDiff,
+           {0, 0, 0},
+           {0, 0, 0},
+           {0, 0, 0},
+           {0, 0, 0}},
+          {640 * 480,
+           15,
+           0,
+           BalancedDegradationSettings::kNoFpsDiff,
+           {0, 0, 0},
+           {0, 0, 0},
+           {0, 0, 0},
+           {0, 0, 0}}};
 }
 
 bool IsValidConfig(
@@ -200,6 +221,7 @@
 BalancedDegradationSettings::Config::Config(int pixels,
                                             int fps,
                                             int kbps,
+                                            int fps_diff,
                                             CodecTypeSpecific vp8,
                                             CodecTypeSpecific vp9,
                                             CodecTypeSpecific h264,
@@ -207,6 +229,7 @@
     : pixels(pixels),
       fps(fps),
       kbps(kbps),
+      fps_diff(fps_diff),
       vp8(vp8),
       vp9(vp9),
       h264(h264),
@@ -217,6 +240,8 @@
       {FieldTrialStructMember("pixels", [](Config* c) { return &c->pixels; }),
        FieldTrialStructMember("fps", [](Config* c) { return &c->fps; }),
        FieldTrialStructMember("kbps", [](Config* c) { return &c->kbps; }),
+       FieldTrialStructMember("fps_diff",
+                              [](Config* c) { return &c->fps_diff; }),
        FieldTrialStructMember("vp8_qp_low",
                               [](Config* c) { return &c->vp8.qp_low; }),
        FieldTrialStructMember("vp8_qp_high",
@@ -292,6 +317,17 @@
   return absl::nullopt;
 }
 
+absl::optional<int> BalancedDegradationSettings::MinFpsDiff(int pixels) const {
+  for (const auto& config : configs_) {
+    if (pixels <= config.pixels) {
+      return (config.fps_diff > kNoFpsDiff)
+                 ? absl::optional<int>(config.fps_diff)
+                 : absl::nullopt;
+    }
+  }
+  return absl::nullopt;
+}
+
 absl::optional<VideoEncoder::QpThresholds>
 BalancedDegradationSettings::GetQpThresholds(VideoCodecType type,
                                              int pixels) const {
diff --git a/rtc_base/experiments/balanced_degradation_settings.h b/rtc_base/experiments/balanced_degradation_settings.h
index e29b7d5..494102e 100644
--- a/rtc_base/experiments/balanced_degradation_settings.h
+++ b/rtc_base/experiments/balanced_degradation_settings.h
@@ -20,6 +20,8 @@
 
 class BalancedDegradationSettings {
  public:
+  static constexpr int kNoFpsDiff = -100;
+
   BalancedDegradationSettings();
   ~BalancedDegradationSettings();
 
@@ -45,6 +47,7 @@
     Config(int pixels,
            int fps,
            int kbps,
+           int fps_diff,
            CodecTypeSpecific vp8,
            CodecTypeSpecific vp9,
            CodecTypeSpecific h264,
@@ -52,14 +55,17 @@
 
     bool operator==(const Config& o) const {
       return pixels == o.pixels && fps == o.fps && kbps == o.kbps &&
-             vp8 == o.vp8 && vp9 == o.vp9 && h264 == o.h264 &&
-             generic == o.generic;
+             fps_diff == o.fps_diff && vp8 == o.vp8 && vp9 == o.vp9 &&
+             h264 == o.h264 && generic == o.generic;
     }
 
     int pixels = 0;  // Video frame size.
     // If the frame size is less than or equal to |pixels|:
     int fps = 0;   // Min framerate to be used.
     int kbps = 0;  // Min bitrate needed to adapt up to this resolution.
+    int fps_diff = kNoFpsDiff;  // Min fps reduction needed (input fps - |fps|)
+                                // w/o triggering a new subsequent downgrade
+                                // check.
     CodecTypeSpecific vp8;
     CodecTypeSpecific vp9;
     CodecTypeSpecific h264;
@@ -76,6 +82,9 @@
   // Gets the bitrate for the first resolution above |pixels|.
   absl::optional<int> NextHigherBitrateKbps(int pixels) const;
 
+  // Gets the min framerate diff from |configs_| based on |pixels|.
+  absl::optional<int> MinFpsDiff(int pixels) const;
+
   // Gets QpThresholds for the codec |type| based on |pixels|.
   absl::optional<VideoEncoder::QpThresholds> GetQpThresholds(
       VideoCodecType type,
diff --git a/rtc_base/experiments/balanced_degradation_settings_unittest.cc b/rtc_base/experiments/balanced_degradation_settings_unittest.cc
index 9aaf55a..4c719d7 100644
--- a/rtc_base/experiments/balanced_degradation_settings_unittest.cc
+++ b/rtc_base/experiments/balanced_degradation_settings_unittest.cc
@@ -21,15 +21,34 @@
 
 void VerifyIsDefault(
     const std::vector<BalancedDegradationSettings::Config>& config) {
-  EXPECT_THAT(
-      config,
-      ::testing::ElementsAre(
-          BalancedDegradationSettings::Config{
-              320 * 240, 7, 0, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}},
-          BalancedDegradationSettings::Config{
-              480 * 270, 10, 0, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}},
-          BalancedDegradationSettings::Config{
-              640 * 480, 15, 0, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}}));
+  EXPECT_THAT(config, ::testing::ElementsAre(
+                          BalancedDegradationSettings::Config{
+                              320 * 240,
+                              7,
+                              0,
+                              BalancedDegradationSettings::kNoFpsDiff,
+                              {0, 0, 0},
+                              {0, 0, 0},
+                              {0, 0, 0},
+                              {0, 0, 0}},
+                          BalancedDegradationSettings::Config{
+                              480 * 270,
+                              10,
+                              0,
+                              BalancedDegradationSettings::kNoFpsDiff,
+                              {0, 0, 0},
+                              {0, 0, 0},
+                              {0, 0, 0},
+                              {0, 0, 0}},
+                          BalancedDegradationSettings::Config{
+                              640 * 480,
+                              15,
+                              0,
+                              BalancedDegradationSettings::kNoFpsDiff,
+                              {0, 0, 0},
+                              {0, 0, 0},
+                              {0, 0, 0},
+                              {0, 0, 0}}));
 }
 }  // namespace
 
@@ -38,6 +57,7 @@
   BalancedDegradationSettings settings;
   VerifyIsDefault(settings.GetConfigs());
   EXPECT_FALSE(settings.NextHigherBitrateKbps(1));
+  EXPECT_FALSE(settings.MinFpsDiff(1));
   EXPECT_FALSE(settings.GetQpThresholds(kVideoCodecVP8, 1));
   EXPECT_FALSE(settings.GetQpThresholds(kVideoCodecVP9, 1));
   EXPECT_FALSE(settings.GetQpThresholds(kVideoCodecH264, 1));
@@ -53,11 +73,32 @@
   EXPECT_THAT(settings.GetConfigs(),
               ::testing::ElementsAre(
                   BalancedDegradationSettings::Config{
-                      11, 5, 0, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}},
+                      11,
+                      5,
+                      0,
+                      BalancedDegradationSettings::kNoFpsDiff,
+                      {0, 0, 0},
+                      {0, 0, 0},
+                      {0, 0, 0},
+                      {0, 0, 0}},
                   BalancedDegradationSettings::Config{
-                      22, 15, 0, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}},
+                      22,
+                      15,
+                      0,
+                      BalancedDegradationSettings::kNoFpsDiff,
+                      {0, 0, 0},
+                      {0, 0, 0},
+                      {0, 0, 0},
+                      {0, 0, 0}},
                   BalancedDegradationSettings::Config{
-                      33, 25, 0, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}}));
+                      33,
+                      25,
+                      0,
+                      BalancedDegradationSettings::kNoFpsDiff,
+                      {0, 0, 0},
+                      {0, 0, 0},
+                      {0, 0, 0},
+                      {0, 0, 0}}));
 }
 
 TEST(BalancedDegradationSettings, GetsDefaultConfigForZeroFpsValue) {
@@ -90,15 +131,35 @@
       "pixels:1000|2000|3000,fps:5|15|25,vp8_fps:7|8|9,vp9_fps:9|10|11,"
       "h264_fps:11|12|13,generic_fps:13|14|15/");
   BalancedDegradationSettings settings;
-  EXPECT_THAT(
-      settings.GetConfigs(),
-      ::testing::ElementsAre(
-          BalancedDegradationSettings::Config{
-              1000, 5, 0, {0, 0, 7}, {0, 0, 9}, {0, 0, 11}, {0, 0, 13}},
-          BalancedDegradationSettings::Config{
-              2000, 15, 0, {0, 0, 8}, {0, 0, 10}, {0, 0, 12}, {0, 0, 14}},
-          BalancedDegradationSettings::Config{
-              3000, 25, 0, {0, 0, 9}, {0, 0, 11}, {0, 0, 13}, {0, 0, 15}}));
+  EXPECT_THAT(settings.GetConfigs(),
+              ::testing::ElementsAre(
+                  BalancedDegradationSettings::Config{
+                      1000,
+                      5,
+                      0,
+                      BalancedDegradationSettings::kNoFpsDiff,
+                      {0, 0, 7},
+                      {0, 0, 9},
+                      {0, 0, 11},
+                      {0, 0, 13}},
+                  BalancedDegradationSettings::Config{
+                      2000,
+                      15,
+                      0,
+                      BalancedDegradationSettings::kNoFpsDiff,
+                      {0, 0, 8},
+                      {0, 0, 10},
+                      {0, 0, 12},
+                      {0, 0, 14}},
+                  BalancedDegradationSettings::Config{
+                      3000,
+                      25,
+                      0,
+                      BalancedDegradationSettings::kNoFpsDiff,
+                      {0, 0, 9},
+                      {0, 0, 11},
+                      {0, 0, 13},
+                      {0, 0, 15}}));
 }
 
 TEST(BalancedDegradationSettings, GetsDefaultConfigForZeroVp8FpsValue) {
@@ -229,11 +290,32 @@
   EXPECT_THAT(settings.GetConfigs(),
               ::testing::ElementsAre(
                   BalancedDegradationSettings::Config{
-                      11, 5, 44, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}},
+                      11,
+                      5,
+                      44,
+                      BalancedDegradationSettings::kNoFpsDiff,
+                      {0, 0, 0},
+                      {0, 0, 0},
+                      {0, 0, 0},
+                      {0, 0, 0}},
                   BalancedDegradationSettings::Config{
-                      22, 15, 88, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}},
+                      22,
+                      15,
+                      88,
+                      BalancedDegradationSettings::kNoFpsDiff,
+                      {0, 0, 0},
+                      {0, 0, 0},
+                      {0, 0, 0},
+                      {0, 0, 0}},
                   BalancedDegradationSettings::Config{
-                      33, 25, 99, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}}));
+                      33,
+                      25,
+                      99,
+                      BalancedDegradationSettings::kNoFpsDiff,
+                      {0, 0, 0},
+                      {0, 0, 0},
+                      {0, 0, 0},
+                      {0, 0, 0}}));
 }
 
 TEST(BalancedDegradationSettings, GetsDefaultConfigIfBitrateDecreases) {
@@ -277,6 +359,31 @@
   EXPECT_FALSE(settings.NextHigherBitrateKbps(2001));
 }
 
+TEST(BalancedDegradationSettings, GetsFpsDiff) {
+  webrtc::test::ScopedFieldTrials field_trials(
+      "WebRTC-Video-BalancedDegradationSettings/"
+      "pixels:1000|2000|3000,fps:5|15|25,fps_diff:0|-2|3/");
+  BalancedDegradationSettings settings;
+  EXPECT_EQ(0, settings.MinFpsDiff(1));
+  EXPECT_EQ(0, settings.MinFpsDiff(1000));
+  EXPECT_EQ(-2, settings.MinFpsDiff(1001));
+  EXPECT_EQ(-2, settings.MinFpsDiff(2000));
+  EXPECT_EQ(3, settings.MinFpsDiff(2001));
+  EXPECT_EQ(3, settings.MinFpsDiff(3000));
+  EXPECT_FALSE(settings.MinFpsDiff(3001));
+}
+
+TEST(BalancedDegradationSettings, GetsNoFpsDiffIfValueBelowMinSetting) {
+  webrtc::test::ScopedFieldTrials field_trials(
+      "WebRTC-Video-BalancedDegradationSettings/"
+      "pixels:1000|2000|3000,fps:5|15|25,fps_diff:-100|-99|-101/");
+  // Min valid fps_diff setting: -99.
+  BalancedDegradationSettings settings;
+  EXPECT_FALSE(settings.MinFpsDiff(1000));
+  EXPECT_EQ(-99, settings.MinFpsDiff(2000));
+  EXPECT_FALSE(settings.MinFpsDiff(3000));
+}
+
 TEST(BalancedDegradationSettings, QpThresholdsNotSetByDefault) {
   webrtc::test::ScopedFieldTrials field_trials(
       "WebRTC-Video-BalancedDegradationSettings/"
@@ -292,19 +399,39 @@
   webrtc::test::ScopedFieldTrials field_trials(
       "WebRTC-Video-BalancedDegradationSettings/"
       "pixels:1000|2000|3000,fps:5|15|25,vp8_qp_low:89|90|88,"
-      "vp8_qp_high:90|91|92,vp9_qp_low:27|28|29,vp9_qp_high:82|83|84,"
+      "vp8_qp_high:90|91|92,vp9_qp_low:27|28|29,vp9_qp_high:120|130|140,"
       "h264_qp_low:12|13|14,h264_qp_high:20|30|40,generic_qp_low:7|6|5,"
       "generic_qp_high:22|23|24/");
   BalancedDegradationSettings settings;
-  EXPECT_THAT(
-      settings.GetConfigs(),
-      ::testing::ElementsAre(
-          BalancedDegradationSettings::Config{
-              1000, 5, 0, {89, 90, 0}, {27, 82, 0}, {12, 20, 0}, {7, 22, 0}},
-          BalancedDegradationSettings::Config{
-              2000, 15, 0, {90, 91, 0}, {28, 83, 0}, {13, 30, 0}, {6, 23, 0}},
-          BalancedDegradationSettings::Config{
-              3000, 25, 0, {88, 92, 0}, {29, 84, 0}, {14, 40, 0}, {5, 24, 0}}));
+  EXPECT_THAT(settings.GetConfigs(),
+              ::testing::ElementsAre(
+                  BalancedDegradationSettings::Config{
+                      1000,
+                      5,
+                      0,
+                      BalancedDegradationSettings::kNoFpsDiff,
+                      {89, 90, 0},
+                      {27, 120, 0},
+                      {12, 20, 0},
+                      {7, 22, 0}},
+                  BalancedDegradationSettings::Config{
+                      2000,
+                      15,
+                      0,
+                      BalancedDegradationSettings::kNoFpsDiff,
+                      {90, 91, 0},
+                      {28, 130, 0},
+                      {13, 30, 0},
+                      {6, 23, 0}},
+                  BalancedDegradationSettings::Config{
+                      3000,
+                      25,
+                      0,
+                      BalancedDegradationSettings::kNoFpsDiff,
+                      {88, 92, 0},
+                      {29, 140, 0},
+                      {14, 40, 0},
+                      {5, 24, 0}}));
 }
 
 TEST(BalancedDegradationSettings, GetsDefaultConfigIfOnlyHasLowThreshold) {
diff --git a/video/overuse_frame_detector_unittest.cc b/video/overuse_frame_detector_unittest.cc
index b66d119..3a1c97c 100644
--- a/video/overuse_frame_detector_unittest.cc
+++ b/video/overuse_frame_detector_unittest.cc
@@ -42,7 +42,7 @@
   virtual ~MockCpuOveruseObserver() {}
 
   MOCK_METHOD1(AdaptUp, void(AdaptReason));
-  MOCK_METHOD1(AdaptDown, void(AdaptReason));
+  MOCK_METHOD1(AdaptDown, bool(AdaptReason));
 };
 
 class CpuOveruseObserverImpl : public AdaptationObserverInterface {
@@ -50,7 +50,10 @@
   CpuOveruseObserverImpl() : overuse_(0), normaluse_(0) {}
   virtual ~CpuOveruseObserverImpl() {}
 
-  void AdaptDown(AdaptReason) { ++overuse_; }
+  bool AdaptDown(AdaptReason) {
+    ++overuse_;
+    return true;
+  }
   void AdaptUp(AdaptReason) { ++normaluse_; }
 
   int overuse_;
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc
index 8e22930..de807db 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -1781,7 +1781,7 @@
   return false;
 }
 
-void VideoStreamEncoder::AdaptDown(AdaptReason reason) {
+bool VideoStreamEncoder::AdaptDown(AdaptReason reason) {
   RTC_DCHECK_RUN_ON(&encoder_queue_);
   AdaptationRequest adaptation_request = {
       last_frame_info_->pixel_count(),
@@ -1792,6 +1792,8 @@
       last_adaptation_request_ &&
       last_adaptation_request_->mode_ == AdaptationRequest::Mode::kAdaptDown;
 
+  bool did_adapt = true;
+
   switch (degradation_preference_) {
     case DegradationPreference::BALANCED:
       break;
@@ -1801,7 +1803,7 @@
               last_adaptation_request_->input_pixel_count_) {
         // Don't request lower resolution if the current resolution is not
         // lower than the last time we asked for the resolution to be lowered.
-        return;
+        return true;
       }
       break;
     case DegradationPreference::MAINTAIN_RESOLUTION:
@@ -1814,11 +1816,11 @@
         // we have to estimate, and can fluctuate naturally over time, don't
         // make the same kind of limitations as for resolution, but trust the
         // overuse detector to not trigger too often.
-        return;
+        return true;
       }
       break;
     case DegradationPreference::DISABLED:
-      return;
+      return true;
   }
 
   switch (degradation_preference_) {
@@ -1828,6 +1830,15 @@
                                           last_frame_info_->pixel_count());
       if (source_proxy_->RestrictFramerate(fps)) {
         GetAdaptCounter().IncrementFramerate(reason);
+        // Check if requested fps is higher (or close to) input fps.
+        absl::optional<int> min_diff =
+            balanced_settings_.MinFpsDiff(last_frame_info_->pixel_count());
+        if (min_diff && adaptation_request.framerate_fps_ > 0) {
+          int fps_diff = adaptation_request.framerate_fps_ - fps;
+          if (fps_diff < min_diff.value()) {
+            did_adapt = false;
+          }
+        }
         break;
       }
       // Scale down resolution.
@@ -1842,7 +1853,7 @@
               &min_pixels_reached)) {
         if (min_pixels_reached)
           encoder_stats_observer_->OnMinPixelLimitReached();
-        return;
+        return true;
       }
       GetAdaptCounter().IncrementResolution(reason);
       break;
@@ -1852,7 +1863,7 @@
       const int requested_framerate = source_proxy_->RequestFramerateLowerThan(
           adaptation_request.framerate_fps_);
       if (requested_framerate == -1)
-        return;
+        return true;
       RTC_DCHECK_NE(max_framerate_, -1);
       overuse_detector_->OnTargetFramerateUpdated(
           std::min(max_framerate_, requested_framerate));
@@ -1868,6 +1879,7 @@
   UpdateAdaptationStats(reason);
 
   RTC_LOG(LS_INFO) << GetConstAdaptCounter().ToString();
+  return did_adapt;
 }
 
 void VideoStreamEncoder::AdaptUp(AdaptReason reason) {
diff --git a/video/video_stream_encoder.h b/video/video_stream_encoder.h
index 3b589bf..b7070f6 100644
--- a/video/video_stream_encoder.h
+++ b/video/video_stream_encoder.h
@@ -103,7 +103,7 @@
   // AdaptationObserverInterface implementation.
   // These methods are protected for easier testing.
   void AdaptUp(AdaptReason reason) override;
-  void AdaptDown(AdaptReason reason) override;
+  bool AdaptDown(AdaptReason reason) override;
 
  private:
   class VideoSourceProxy;
diff --git a/video/video_stream_encoder_unittest.cc b/video/video_stream_encoder_unittest.cc
index 35439d2..1ad4cbf 100644
--- a/video/video_stream_encoder_unittest.cc
+++ b/video/video_stream_encoder_unittest.cc
@@ -148,7 +148,10 @@
   void PostTaskAndWait(bool down, AdaptReason reason) {
     rtc::Event event;
     encoder_queue()->PostTask([this, &event, reason, down] {
-      down ? AdaptDown(reason) : AdaptUp(reason);
+      if (down)
+        AdaptDown(reason);
+      else
+        AdaptUp(reason);
       event.Set();
     });
     ASSERT_TRUE(event.Wait(5000));