path: root/call/adaptation/resource_adaptation_processor_unittest.cc

/*
 *  Copyright (c) 2020 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 "call/adaptation/resource_adaptation_processor.h"

#include "api/scoped_refptr.h"
#include "api/video/video_adaptation_counters.h"
#include "call/adaptation/resource.h"
#include "call/adaptation/resource_adaptation_processor_interface.h"
#include "call/adaptation/test/fake_frame_rate_provider.h"
#include "call/adaptation/test/fake_resource.h"
#include "call/adaptation/video_source_restrictions.h"
#include "call/adaptation/video_stream_input_state_provider.h"
#include "rtc_base/event.h"
#include "rtc_base/task_queue_for_test.h"
#include "test/gtest.h"

namespace webrtc {

namespace {

const int kDefaultFrameRate = 30;
const int kDefaultFrameSize = 1280 * 720;

class ResourceAdaptationProcessorListenerForTesting
    : public ResourceAdaptationProcessorListener {
 public:
  ResourceAdaptationProcessorListenerForTesting()
      : restrictions_updated_count_(0),
        restrictions_(),
        adaptation_counters_(),
        reason_(nullptr) {}
  ~ResourceAdaptationProcessorListenerForTesting() override {}

  size_t restrictions_updated_count() const {
    return restrictions_updated_count_;
  }
  const VideoSourceRestrictions& restrictions() const { return restrictions_; }
  const VideoAdaptationCounters& adaptation_counters() const {
    return adaptation_counters_;
  }
  rtc::scoped_refptr<Resource> reason() const { return reason_; }

  // ResourceAdaptationProcessorListener implementation.
  void OnVideoSourceRestrictionsUpdated(
      VideoSourceRestrictions restrictions,
      const VideoAdaptationCounters& adaptation_counters,
      rtc::scoped_refptr<Resource> reason) override {
    ++restrictions_updated_count_;
    restrictions_ = restrictions;
    adaptation_counters_ = adaptation_counters;
    reason_ = reason;
  }

 private:
  size_t restrictions_updated_count_;
  VideoSourceRestrictions restrictions_;
  VideoAdaptationCounters adaptation_counters_;
  rtc::scoped_refptr<Resource> reason_;
};

class ResourceAdaptationProcessorTest : public ::testing::Test {
 public:
  ResourceAdaptationProcessorTest()
      : resource_adaptation_queue_("ResourceAdaptationQueue"),
        encoder_queue_("EncoderQueue"),
        frame_rate_provider_(),
        input_state_provider_(&frame_rate_provider_),
        resource_(new FakeResource("FakeResource")),
        other_resource_(new FakeResource("OtherFakeResource")),
        processor_(std::make_unique<ResourceAdaptationProcessor>(
            &input_state_provider_,
            /*encoder_stats_observer=*/&frame_rate_provider_)) {
    resource_->Initialize(&encoder_queue_, &resource_adaptation_queue_);
    other_resource_->Initialize(&encoder_queue_, &resource_adaptation_queue_);
    rtc::Event event;
    resource_adaptation_queue_.PostTask([this, &event] {
      processor_->InitializeOnResourceAdaptationQueue();
      processor_->AddAdaptationListener(&processor_listener_);
      processor_->AddResource(resource_);
      processor_->AddResource(other_resource_);
      event.Set();
    });
    event.Wait(rtc::Event::kForever);
  }
  ~ResourceAdaptationProcessorTest() override {
    rtc::Event event;
    resource_adaptation_queue_.PostTask([this, &event] {
      processor_->StopResourceAdaptation();
      processor_->RemoveResource(resource_);
      processor_->RemoveResource(other_resource_);
      processor_->RemoveAdaptationListener(&processor_listener_);
      processor_.reset();
      event.Set();
    });
    event.Wait(rtc::Event::kForever);
  }

  void SetInputStates(bool has_input, int fps, int frame_size) {
    input_state_provider_.OnHasInputChanged(has_input);
    frame_rate_provider_.set_fps(fps);
    input_state_provider_.OnFrameSizeObserved(frame_size);
  }

  void RestrictSource(VideoSourceRestrictions restrictions) {
    SetInputStates(
        true, restrictions.max_frame_rate().value_or(kDefaultFrameRate),
        restrictions.target_pixels_per_frame().has_value()
            ? restrictions.target_pixels_per_frame().value()
            : restrictions.max_pixels_per_frame().value_or(kDefaultFrameSize));
  }

 protected:
  TaskQueueForTest resource_adaptation_queue_;
  TaskQueueForTest encoder_queue_;
  FakeFrameRateProvider frame_rate_provider_;
  VideoStreamInputStateProvider input_state_provider_;
  rtc::scoped_refptr<FakeResource> resource_;
  rtc::scoped_refptr<FakeResource> other_resource_;
  std::unique_ptr<ResourceAdaptationProcessor> processor_;
  ResourceAdaptationProcessorListenerForTesting processor_listener_;
};

}  // namespace

TEST_F(ResourceAdaptationProcessorTest, DisabledByDefault) {
  resource_adaptation_queue_.SendTask(
      [this] {
        EXPECT_EQ(DegradationPreference::DISABLED,
                  processor_->degradation_preference());
        EXPECT_EQ(DegradationPreference::DISABLED,
                  processor_->effective_degradation_preference());
        SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
        processor_->StartResourceAdaptation();
        // Adaptation does not happen when disabled.
        resource_->set_usage_state(ResourceUsageState::kOveruse);
        EXPECT_EQ(0u, processor_listener_.restrictions_updated_count());
      },
      RTC_FROM_HERE);
}

TEST_F(ResourceAdaptationProcessorTest, InsufficientInput) {
  resource_adaptation_queue_.SendTask(
      [this] {
        processor_->SetDegradationPreference(
            DegradationPreference::MAINTAIN_FRAMERATE);
        processor_->StartResourceAdaptation();
        // Adaptation does not happen if input is insufficient.
        // When frame size is missing (OnFrameSizeObserved not called yet).
        input_state_provider_.OnHasInputChanged(true);
        resource_->set_usage_state(ResourceUsageState::kOveruse);
        EXPECT_EQ(0u, processor_listener_.restrictions_updated_count());
        // When "has input" is missing.
        SetInputStates(false, kDefaultFrameRate, kDefaultFrameSize);
        resource_->set_usage_state(ResourceUsageState::kOveruse);
        EXPECT_EQ(0u, processor_listener_.restrictions_updated_count());
        // Note: frame rate cannot be missing, if unset it is 0.
      },
      RTC_FROM_HERE);
}

// These tests verify that restrictions are applied, but not exactly how much
// the source is restricted. This ensures that the VideoStreamAdapter is wired
// up correctly but not exactly how the VideoStreamAdapter generates
// restrictions. For that, see video_stream_adapter_unittest.cc.
TEST_F(ResourceAdaptationProcessorTest,
       OveruseTriggersRestrictingResolutionInMaintainFrameRate) {
  resource_adaptation_queue_.SendTask(
      [this] {
        processor_->SetDegradationPreference(
            DegradationPreference::MAINTAIN_FRAMERATE);
        processor_->StartResourceAdaptation();
        SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
        resource_->set_usage_state(ResourceUsageState::kOveruse);
        EXPECT_EQ(1u, processor_listener_.restrictions_updated_count());
        EXPECT_TRUE(processor_listener_.restrictions()
                        .max_pixels_per_frame()
                        .has_value());
      },
      RTC_FROM_HERE);
}

TEST_F(ResourceAdaptationProcessorTest,
       OveruseTriggersRestrictingFrameRateInMaintainResolution) {
  resource_adaptation_queue_.SendTask(
      [this] {
        processor_->SetDegradationPreference(
            DegradationPreference::MAINTAIN_RESOLUTION);
        processor_->StartResourceAdaptation();
        SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
        resource_->set_usage_state(ResourceUsageState::kOveruse);
        EXPECT_EQ(1u, processor_listener_.restrictions_updated_count());
        EXPECT_TRUE(
            processor_listener_.restrictions().max_frame_rate().has_value());
      },
      RTC_FROM_HERE);
}

TEST_F(ResourceAdaptationProcessorTest,
       OveruseTriggersRestrictingFrameRateAndResolutionInBalanced) {
  resource_adaptation_queue_.SendTask(
      [this] {
        processor_->SetDegradationPreference(DegradationPreference::BALANCED);
        processor_->StartResourceAdaptation();
        SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
        // Adapting multiple times eventually resticts both frame rate and
        // resolution. Exactly many times we need to adapt depends on
        // BalancedDegradationSettings, VideoStreamAdapter and default input
        // states. This test requires it to be achieved within 4 adaptations.
        for (size_t i = 0; i < 4; ++i) {
          resource_->set_usage_state(ResourceUsageState::kOveruse);
          EXPECT_EQ(i + 1, processor_listener_.restrictions_updated_count());
          RestrictSource(processor_listener_.restrictions());
        }
        EXPECT_TRUE(processor_listener_.restrictions()
                        .max_pixels_per_frame()
                        .has_value());
        EXPECT_TRUE(
            processor_listener_.restrictions().max_frame_rate().has_value());
      },
      RTC_FROM_HERE);
}

TEST_F(ResourceAdaptationProcessorTest, AwaitingPreviousAdaptation) {
  resource_adaptation_queue_.SendTask(
      [this] {
        processor_->SetDegradationPreference(
            DegradationPreference::MAINTAIN_FRAMERATE);
        processor_->StartResourceAdaptation();
        SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
        resource_->set_usage_state(ResourceUsageState::kOveruse);
        EXPECT_EQ(1u, processor_listener_.restrictions_updated_count());
        // If we don't restrict the source then adaptation will not happen again
        // due to "awaiting previous adaptation". This prevents "double-adapt".
        resource_->set_usage_state(ResourceUsageState::kOveruse);
        EXPECT_EQ(1u, processor_listener_.restrictions_updated_count());
      },
      RTC_FROM_HERE);
}

TEST_F(ResourceAdaptationProcessorTest, CannotAdaptUpWhenUnrestricted) {
  resource_adaptation_queue_.SendTask(
      [this] {
        processor_->SetDegradationPreference(
            DegradationPreference::MAINTAIN_FRAMERATE);
        processor_->StartResourceAdaptation();
        SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
        resource_->set_usage_state(ResourceUsageState::kUnderuse);
        EXPECT_EQ(0u, processor_listener_.restrictions_updated_count());
      },
      RTC_FROM_HERE);
}

TEST_F(ResourceAdaptationProcessorTest, UnderuseTakesUsBackToUnrestricted) {
  resource_adaptation_queue_.SendTask(
      [this] {
        processor_->SetDegradationPreference(
            DegradationPreference::MAINTAIN_FRAMERATE);
        processor_->StartResourceAdaptation();
        SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
        resource_->set_usage_state(ResourceUsageState::kOveruse);
        EXPECT_EQ(1u, processor_listener_.restrictions_updated_count());
        RestrictSource(processor_listener_.restrictions());
        resource_->set_usage_state(ResourceUsageState::kUnderuse);
        EXPECT_EQ(2u, processor_listener_.restrictions_updated_count());
        EXPECT_EQ(VideoSourceRestrictions(),
                  processor_listener_.restrictions());
      },
      RTC_FROM_HERE);
}

TEST_F(ResourceAdaptationProcessorTest, ResourcesCanPreventAdaptingUp) {
  resource_adaptation_queue_.SendTask(
      [this] {
        processor_->SetDegradationPreference(
            DegradationPreference::MAINTAIN_FRAMERATE);
        processor_->StartResourceAdaptation();
        SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
        // Adapt down so that we can adapt up.
        resource_->set_usage_state(ResourceUsageState::kOveruse);
        EXPECT_EQ(1u, processor_listener_.restrictions_updated_count());
        RestrictSource(processor_listener_.restrictions());
        // Adapting up is prevented.
        resource_->set_is_adaptation_up_allowed(false);
        resource_->set_usage_state(ResourceUsageState::kUnderuse);
        EXPECT_EQ(1u, processor_listener_.restrictions_updated_count());
      },
      RTC_FROM_HERE);
}

TEST_F(ResourceAdaptationProcessorTest,
       ResourcesCanNotAdaptUpIfNeverAdaptedDown) {
  resource_adaptation_queue_.SendTask(
      [this] {
        processor_->SetDegradationPreference(
            DegradationPreference::MAINTAIN_FRAMERATE);
        processor_->StartResourceAdaptation();
        SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
        resource_->set_usage_state(ResourceUsageState::kOveruse);
        EXPECT_EQ(1u, processor_listener_.restrictions_updated_count());
        RestrictSource(processor_listener_.restrictions());

        // Other resource signals under-use
        other_resource_->set_usage_state(ResourceUsageState::kUnderuse);
        EXPECT_EQ(1u, processor_listener_.restrictions_updated_count());
      },
      RTC_FROM_HERE);
}

TEST_F(ResourceAdaptationProcessorTest,
       ResourcesCanNotAdaptUpIfNotAdaptedDownAfterReset) {
  resource_adaptation_queue_.SendTask(
      [this] {
        processor_->SetDegradationPreference(
            DegradationPreference::MAINTAIN_FRAMERATE);
        processor_->StartResourceAdaptation();
        SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
        resource_->set_usage_state(ResourceUsageState::kOveruse);
        EXPECT_EQ(1u, processor_listener_.restrictions_updated_count());

        processor_->ResetVideoSourceRestrictions();
        EXPECT_EQ(0, processor_listener_.adaptation_counters().Total());
        other_resource_->set_usage_state(ResourceUsageState::kOveruse);
        EXPECT_EQ(1, processor_listener_.adaptation_counters().Total());
        RestrictSource(processor_listener_.restrictions());

        // resource_ did not overuse after we reset the restrictions, so adapt
        // up should be disallowed.
        resource_->set_usage_state(ResourceUsageState::kUnderuse);
        EXPECT_EQ(1, processor_listener_.adaptation_counters().Total());
      },
      RTC_FROM_HERE);
}

TEST_F(ResourceAdaptationProcessorTest,
       MultipleResourcesCanTriggerMultipleAdaptations) {
  resource_adaptation_queue_.SendTask(
      [this] {
        processor_->SetDegradationPreference(
            DegradationPreference::MAINTAIN_FRAMERATE);
        processor_->StartResourceAdaptation();
        SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
        resource_->set_usage_state(ResourceUsageState::kOveruse);
        EXPECT_EQ(1, processor_listener_.adaptation_counters().Total());
        RestrictSource(processor_listener_.restrictions());
        other_resource_->set_usage_state(ResourceUsageState::kOveruse);
        EXPECT_EQ(2, processor_listener_.adaptation_counters().Total());
        RestrictSource(processor_listener_.restrictions());
        other_resource_->set_usage_state(ResourceUsageState::kOveruse);
        EXPECT_EQ(3, processor_listener_.adaptation_counters().Total());
        RestrictSource(processor_listener_.restrictions());

        resource_->set_usage_state(ResourceUsageState::kUnderuse);
        EXPECT_EQ(2, processor_listener_.adaptation_counters().Total());
        RestrictSource(processor_listener_.restrictions());
        // Does not trigger adaptation since resource has no adaptations left.
        resource_->set_usage_state(ResourceUsageState::kUnderuse);
        EXPECT_EQ(2, processor_listener_.adaptation_counters().Total());
        RestrictSource(processor_listener_.restrictions());

        other_resource_->set_usage_state(ResourceUsageState::kUnderuse);
        EXPECT_EQ(1, processor_listener_.adaptation_counters().Total());
        RestrictSource(processor_listener_.restrictions());
        other_resource_->set_usage_state(ResourceUsageState::kUnderuse);
        EXPECT_EQ(0, processor_listener_.adaptation_counters().Total());
        RestrictSource(processor_listener_.restrictions());
      },
      RTC_FROM_HERE);
}

TEST_F(ResourceAdaptationProcessorTest, AdaptingTriggersOnAdaptationApplied) {
  resource_adaptation_queue_.SendTask(
      [this] {
        processor_->SetDegradationPreference(
            DegradationPreference::MAINTAIN_FRAMERATE);
        processor_->StartResourceAdaptation();
        SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
        resource_->set_usage_state(ResourceUsageState::kOveruse);
        EXPECT_EQ(1u, resource_->num_adaptations_applied());
      },
      RTC_FROM_HERE);
}

TEST_F(ResourceAdaptationProcessorTest, AdaptingClearsResourceUsageState) {
  resource_adaptation_queue_.SendTask(
      [this] {
        processor_->SetDegradationPreference(
            DegradationPreference::MAINTAIN_FRAMERATE);
        processor_->StartResourceAdaptation();
        SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
        resource_->set_usage_state(ResourceUsageState::kOveruse);
        EXPECT_EQ(1u, processor_listener_.restrictions_updated_count());
        EXPECT_FALSE(resource_->usage_state().has_value());
      },
      RTC_FROM_HERE);
}

TEST_F(ResourceAdaptationProcessorTest,
       FailingAdaptingAlsoClearsResourceUsageState) {
  resource_adaptation_queue_.SendTask(
      [this] {
        processor_->SetDegradationPreference(DegradationPreference::DISABLED);
        processor_->StartResourceAdaptation();
        resource_->set_usage_state(ResourceUsageState::kOveruse);
        EXPECT_EQ(0u, processor_listener_.restrictions_updated_count());
        EXPECT_FALSE(resource_->usage_state().has_value());
      },
      RTC_FROM_HERE);
}

TEST_F(ResourceAdaptationProcessorTest,
       AdaptsDownWhenOtherResourceIsAlwaysUnderused) {
  resource_adaptation_queue_.SendTask(
      [this] {
        processor_->SetDegradationPreference(
            DegradationPreference::MAINTAIN_FRAMERATE);
        processor_->StartResourceAdaptation();
        SetInputStates(true, kDefaultFrameRate, kDefaultFrameSize);
        other_resource_->set_usage_state(ResourceUsageState::kUnderuse);
        // Does not trigger adapataion because there's no restriction.
        EXPECT_EQ(0, processor_listener_.adaptation_counters().Total());

        RestrictSource(processor_listener_.restrictions());
        resource_->set_usage_state(ResourceUsageState::kOveruse);
        // Adapts down even if other resource asked for adapting up.
        EXPECT_EQ(1, processor_listener_.adaptation_counters().Total());

        RestrictSource(processor_listener_.restrictions());
        other_resource_->set_usage_state(ResourceUsageState::kUnderuse);
        // Doesn't adapt up because adaptation is due to another resource.
        EXPECT_EQ(1, processor_listener_.adaptation_counters().Total());
        RestrictSource(processor_listener_.restrictions());
      },
      RTC_FROM_HERE);
}

}  // namespace webrtc