mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-12 21:30:45 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Unify AdaptationReason and AdaptReason enums.

Browse source 
Moves the unified AdaptationReason to the api/ folder.

Bug: webrtc:11392
Change-Id: I28782e82ef6cc3ca3b061f65b0bbdc3766df1f9c
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/172583
Commit-Queue: Evan Shrubsole <eshr@google.com>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Reviewed-by: Niels Moller <nisse@webrtc.org>
Reviewed-by: Henrik Boström <hbos@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31084}
This commit is contained in:
Evan Shrubsole 2020-04-16 11:36:55 +02:00 committed by Commit Bot
parent dff792591f
commit ce0a11d5f9
25 changed files with 273 additions and 308 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
api/video/BUILD.gn
View file

@ -234,6 +234,7 @@ rtc_library("video_adaptation") {
sources = [
"video_adaptation_counters.cc",
"video_adaptation_counters.h",
"video_adaptation_reason.h",
]
deps = [ "../../rtc_base:checks" ]

20
api/video/video_adaptation_reason.h Normal file
View file

@ -0,0 +1,20 @@
/*
* 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.
*/
#ifndef API_VIDEO_VIDEO_ADAPTATION_REASON_H_
#define API_VIDEO_VIDEO_ADAPTATION_REASON_H_
namespace webrtc {
enum class VideoAdaptationReason { kQuality, kCpu };
} // namespace webrtc
#endif // API_VIDEO_VIDEO_ADAPTATION_REASON_H_

11
api/video/video_stream_encoder_observer.h
View file

@ -16,6 +16,7 @@
#include "absl/types/optional.h"
#include "api/video/video_adaptation_counters.h"
#include "api/video/video_adaptation_reason.h"
#include "api/video/video_bitrate_allocation.h"
#include "api/video/video_codec_constants.h"
#include "api/video_codecs/video_encoder.h"
@ -39,14 +40,6 @@ class CpuOveruseMetricsObserver {
class VideoStreamEncoderObserver : public CpuOveruseMetricsObserver {
public:
// TODO(nisse): There are too many enums to represent this. Besides
// this one, see AdaptationObserverInterface::AdaptReason and
// WebRtcVideoChannel::AdaptReason.
enum class AdaptationReason {
kCpu,
kQuality,
};
struct AdaptationSettings {
AdaptationSettings()
: resolution_scaling_enabled(false), framerate_scaling_enabled(false) {}
@ -90,7 +83,7 @@ class VideoStreamEncoderObserver : public CpuOveruseMetricsObserver {
const std::vector<VideoStream>& streams) = 0;
virtual void OnAdaptationChanged(
AdaptationReason reason,
VideoAdaptationReason reason,
const VideoAdaptationCounters& cpu_steps,
const VideoAdaptationCounters& quality_steps) = 0;
virtual void ClearAdaptationStats() = 0;

4
modules/video_coding/BUILD.gn
View file

@ -83,6 +83,7 @@ rtc_library("video_coding") {
"../../api:array_view",
"../../api:scoped_refptr",
"../../api/video:encoded_image",
"../../api/video:video_adaptation",
"../../api/video:video_bitrate_allocation",
"../../api/video:video_bitrate_allocator_factory",
"../../rtc_base:deprecation",
@ -153,6 +154,7 @@ rtc_library("video_coding") {
"../../api/units:time_delta",
"../../api/video:builtin_video_bitrate_allocator_factory",
"../../api/video:encoded_frame",
"../../api/video:video_adaptation",
"../../api/video:video_bitrate_allocator",
"../../api/video:video_frame",
"../../api/video:video_frame_i420",
@ -303,6 +305,7 @@ rtc_library("video_coding_utility") {
"..:module_api",
"../../api/video:encoded_frame",
"../../api/video:encoded_image",
"../../api/video:video_adaptation",
"../../api/video:video_bitrate_allocation",
"../../api/video:video_bitrate_allocator",
"../../api/video_codecs:video_codecs_api",
@ -914,6 +917,7 @@ if (rtc_include_tests) {
"../../api/task_queue:default_task_queue_factory",
"../../api/test/video:function_video_factory",
"../../api/video:builtin_video_bitrate_allocator_factory",
"../../api/video:video_adaptation",
"../../api/video:video_bitrate_allocation",
"../../api/video:video_bitrate_allocator",
"../../api/video:video_bitrate_allocator_factory",

6
modules/video_coding/utility/quality_scaler.cc
View file

@ -13,6 +13,7 @@
#include <memory>
#include <utility>
#include "api/video/video_adaptation_reason.h"
#include "rtc_base/checks.h"
#include "rtc_base/experiments/quality_scaler_settings.h"
#include "rtc_base/logging.h"
@ -234,15 +235,14 @@ void QualityScaler::CheckQp() {
void QualityScaler::ReportQpLow() {
RTC_DCHECK_RUN_ON(&task_checker_);
ClearSamples();
observer_->AdaptUp(AdaptationObserverInterface::AdaptReason::kQuality);
observer_->AdaptUp(VideoAdaptationReason::kQuality);
adapt_called_ = true;
}
void QualityScaler::ReportQpHigh() {
RTC_DCHECK_RUN_ON(&task_checker_);
if (observer_->AdaptDown(
AdaptationObserverInterface::AdaptReason::kQuality)) {
if (observer_->AdaptDown(VideoAdaptationReason::kQuality)) {
ClearSamples();
} else {
adapt_failed_ = true;

9
modules/video_coding/utility/quality_scaler.h
View file

@ -17,6 +17,7 @@
#include <memory>
#include "absl/types/optional.h"
#include "api/video/video_adaptation_reason.h"
#include "api/video_codecs/video_encoder.h"
#include "rtc_base/experiments/quality_scaling_experiment.h"
#include "rtc_base/numerics/moving_average.h"
@ -35,16 +36,12 @@ namespace webrtc {
// stream.
class AdaptationObserverInterface {
public:
// Indicates if the adaptation is due to overuse of the CPU resources, or if
// the quality of the encoded frames have dropped too low.
enum AdaptReason : size_t { kQuality = 0, kCpu = 1 };
static const size_t kScaleReasonSize = 2;
// Called to signal that we can handle larger or more frequent frames.
virtual void AdaptUp(AdaptReason reason) = 0;
virtual void AdaptUp(VideoAdaptationReason reason) = 0;
// Called to signal that the source should reduce the resolution or framerate.
// 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;
virtual bool AdaptDown(VideoAdaptationReason reason) = 0;
protected:
virtual ~AdaptationObserverInterface() {}

5
modules/video_coding/utility/quality_scaler_unittest.cc
View file

@ -13,6 +13,7 @@
#include <memory>
#include <string>
#include "api/video/video_adaptation_reason.h"
#include "rtc_base/checks.h"
#include "rtc_base/event.h"
#include "rtc_base/task_queue_for_test.h"
@ -32,11 +33,11 @@ class MockAdaptationObserver : public AdaptationObserverInterface {
public:
virtual ~MockAdaptationObserver() {}
void AdaptUp(AdaptReason r) override {
void AdaptUp(VideoAdaptationReason r) override {
adapt_up_events_++;
event.Set();
}
bool AdaptDown(AdaptReason r) override {
bool AdaptDown(VideoAdaptationReason r) override {
adapt_down_events_++;
event.Set();
return true;

2
video/BUILD.gn
View file

@ -199,6 +199,7 @@ rtc_library("video_stream_encoder_impl") {
"../api/task_queue:task_queue",
"../api/units:data_rate",
"../api/video:encoded_image",
"../api/video:video_adaptation",
"../api/video:video_bitrate_allocation",
"../api/video:video_bitrate_allocator",
"../api/video:video_bitrate_allocator_factory",
@ -548,6 +549,7 @@ if (rtc_include_tests) {
"../api/units:timestamp",
"../api/video:builtin_video_bitrate_allocator_factory",
"../api/video:encoded_image",
"../api/video:video_adaptation",
"../api/video:video_bitrate_allocation",
"../api/video:video_frame",
"../api/video:video_frame_i420",

9
video/adaptation/encode_usage_resource.cc
View file

@ -13,6 +13,7 @@
#include <limits>
#include <utility>
#include "api/video/video_adaptation_reason.h"
#include "rtc_base/checks.h"
namespace webrtc {
@ -65,13 +66,13 @@ void EncodeUsageResource::OnEncodeCompleted(
encode_duration_us);
}
void EncodeUsageResource::AdaptUp(AdaptReason reason) {
RTC_DCHECK_EQ(reason, AdaptReason::kCpu);
void EncodeUsageResource::AdaptUp(VideoAdaptationReason reason) {
RTC_DCHECK_EQ(reason, VideoAdaptationReason::kCpu);
OnResourceUsageStateMeasured(ResourceUsageState::kUnderuse);
}
bool EncodeUsageResource::AdaptDown(AdaptReason reason) {
RTC_DCHECK_EQ(reason, AdaptReason::kCpu);
bool EncodeUsageResource::AdaptDown(VideoAdaptationReason reason) {
RTC_DCHECK_EQ(reason, VideoAdaptationReason::kCpu);
return OnResourceUsageStateMeasured(ResourceUsageState::kOveruse) !=
ResourceListenerResponse::kQualityScalerShouldIncreaseFrequency;
}

5
video/adaptation/encode_usage_resource.h
View file

@ -15,6 +15,7 @@
#include <string>
#include "absl/types/optional.h"
#include "api/video/video_adaptation_reason.h"
#include "call/adaptation/resource.h"
#include "modules/video_coding/utility/quality_scaler.h"
#include "video/adaptation/overuse_frame_detector.h"
@ -48,8 +49,8 @@ class EncodeUsageResource : public Resource,
// AdaptationObserverInterface implementation.
// TODO(https://crbug.com/webrtc/11222, 11172): This resource also needs to
// signal when its stable to support multi-stream aware modules.
void AdaptUp(AdaptReason reason) override;
bool AdaptDown(AdaptReason reason) override;
void AdaptUp(VideoAdaptationReason reason) override;
bool AdaptDown(VideoAdaptationReason reason) override;
std::string name() const override { return "EncoderUsageResource"; }

3
video/adaptation/overuse_frame_detector.cc
View file

@ -20,6 +20,7 @@
#include <string>
#include <utility>
#include "api/video/video_adaptation_reason.h"
#include "api/video/video_frame.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
@ -64,7 +65,7 @@ const float kMaxSampleDiffMarginFactor = 1.35f;
const int kMinFramerate = 7;
const int kMaxFramerate = 30;
const auto kScaleReasonCpu = AdaptationObserverInterface::AdaptReason::kCpu;
const auto kScaleReasonCpu = VideoAdaptationReason::kCpu;
// Class for calculating the processing usage on the send-side (the average
// processing time of a frame divided by the average time difference between

11
video/adaptation/overuse_frame_detector_unittest.cc
View file

@ -14,6 +14,7 @@
#include "api/video/encoded_image.h"
#include "api/video/i420_buffer.h"
#include "api/video/video_adaptation_reason.h"
#include "modules/video_coding/utility/quality_scaler.h"
#include "rtc_base/event.h"
#include "rtc_base/fake_clock.h"
@ -40,8 +41,8 @@ class MockCpuOveruseObserver : public AdaptationObserverInterface {
MockCpuOveruseObserver() {}
virtual ~MockCpuOveruseObserver() {}
MOCK_METHOD1(AdaptUp, void(AdaptReason));
MOCK_METHOD1(AdaptDown, bool(AdaptReason));
MOCK_METHOD1(AdaptUp, void(VideoAdaptationReason));
MOCK_METHOD1(AdaptDown, bool(VideoAdaptationReason));
};
class CpuOveruseObserverImpl : public AdaptationObserverInterface {
@ -49,11 +50,11 @@ class CpuOveruseObserverImpl : public AdaptationObserverInterface {
CpuOveruseObserverImpl() : overuse_(0), normaluse_(0) {}
virtual ~CpuOveruseObserverImpl() {}
bool AdaptDown(AdaptReason) override {
bool AdaptDown(VideoAdaptationReason) override {
++overuse_;
return true;
}
void AdaptUp(AdaptReason) override { ++normaluse_; }
void AdaptUp(VideoAdaptationReason) override { ++normaluse_; }
int overuse_;
int normaluse_;
@ -235,7 +236,7 @@ class OveruseFrameDetectorTest : public ::testing::Test,
std::unique_ptr<OveruseFrameDetectorUnderTest> overuse_detector_;
int encode_usage_percent_ = -1;
static const auto reason_ = AdaptationObserverInterface::AdaptReason::kCpu;
static const auto reason_ = VideoAdaptationReason::kCpu;
};
// UsagePercent() > high_encode_usage_threshold_percent => overuse.

8
video/adaptation/quality_scaler_resource.cc
View file

@ -62,13 +62,13 @@ void QualityScalerResource::OnFrameDropped(
}
}
void QualityScalerResource::AdaptUp(AdaptReason reason) {
RTC_DCHECK_EQ(reason, AdaptReason::kQuality);
void QualityScalerResource::AdaptUp(VideoAdaptationReason reason) {
RTC_DCHECK_EQ(reason, VideoAdaptationReason::kQuality);
OnResourceUsageStateMeasured(ResourceUsageState::kUnderuse);
}
bool QualityScalerResource::AdaptDown(AdaptReason reason) {
RTC_DCHECK_EQ(reason, AdaptReason::kQuality);
bool QualityScalerResource::AdaptDown(VideoAdaptationReason reason) {
RTC_DCHECK_EQ(reason, VideoAdaptationReason::kQuality);
return OnResourceUsageStateMeasured(ResourceUsageState::kOveruse) !=
ResourceListenerResponse::kQualityScalerShouldIncreaseFrequency;
}

5
video/adaptation/quality_scaler_resource.h
View file

@ -14,6 +14,7 @@
#include <memory>
#include <string>
#include "api/video/video_adaptation_reason.h"
#include "api/video_codecs/video_encoder.h"
#include "call/adaptation/resource.h"
#include "modules/video_coding/utility/quality_scaler.h"
@ -46,8 +47,8 @@ class QualityScalerResource : public Resource,
// AdaptationObserverInterface implementation.
// TODO(https://crbug.com/webrtc/11222, 11172): This resource also needs to
// signal when its stable to support multi-stream aware modules.
void AdaptUp(AdaptReason reason) override;
bool AdaptDown(AdaptReason reason) override;
void AdaptUp(VideoAdaptationReason reason) override;
bool AdaptDown(VideoAdaptationReason reason) override;
std::string name() const override { return "QualityScalerResource"; }

83
video/adaptation/resource_adaptation_processor.cc
View file

@ -19,6 +19,7 @@
#include "absl/algorithm/container.h"
#include "absl/base/macros.h"
#include "api/task_queue/task_queue_base.h"
#include "api/video/video_adaptation_reason.h"
#include "api/video/video_source_interface.h"
#include "call/adaptation/resource.h"
#include "call/adaptation/video_source_restrictions.h"
@ -93,13 +94,21 @@ VideoAdaptationCounters ApplyDegradationPreference(
return counters;
}
VideoStreamEncoderObserver::AdaptationReason ToAdaptationReason(
AdaptationObserverInterface::AdaptReason reason) {
std::string ToString(VideoAdaptationReason reason) {
switch (reason) {
case AdaptationObserverInterface::kQuality:
return VideoStreamEncoderObserver::AdaptationReason::kQuality;
case AdaptationObserverInterface::kCpu:
return VideoStreamEncoderObserver::AdaptationReason::kCpu;
case VideoAdaptationReason::kQuality:
return "quality";
case VideoAdaptationReason::kCpu:
return "cpu";
}
}
VideoAdaptationReason OtherReason(VideoAdaptationReason reason) {
switch (reason) {
case VideoAdaptationReason::kQuality:
return VideoAdaptationReason::kCpu;
case VideoAdaptationReason::kCpu:
return VideoAdaptationReason::kQuality;
}
}
@ -205,10 +214,8 @@ ResourceAdaptationProcessor::ResourceAdaptationProcessor(
active_counts_() {
RTC_DCHECK(adaptation_listener_);
RTC_DCHECK(encoder_stats_observer_);
AddResource(encode_usage_resource_.get(),
AdaptationObserverInterface::AdaptReason::kCpu);
AddResource(quality_scaler_resource_.get(),
AdaptationObserverInterface::AdaptReason::kQuality);
AddResource(encode_usage_resource_.get(), VideoAdaptationReason::kCpu);
AddResource(quality_scaler_resource_.get(), VideoAdaptationReason::kQuality);
}
ResourceAdaptationProcessor::~ResourceAdaptationProcessor() {
@ -240,12 +247,11 @@ void ResourceAdaptationProcessor::StopResourceAdaptation() {
}
void ResourceAdaptationProcessor::AddResource(Resource* resource) {
return AddResource(resource, AdaptationObserverInterface::AdaptReason::kCpu);
return AddResource(resource, VideoAdaptationReason::kCpu);
}
void ResourceAdaptationProcessor::AddResource(
Resource* resource,
AdaptationObserverInterface::AdaptReason reason) {
void ResourceAdaptationProcessor::AddResource(Resource* resource,
VideoAdaptationReason reason) {
RTC_DCHECK(resource);
RTC_DCHECK(absl::c_find_if(resources_,
[resource](const ResourceAndReason& r) {
@ -268,7 +274,7 @@ void ResourceAdaptationProcessor::SetDegradationPreference(
if (stream_adapter_->SetDegradationPreference(degradation_preference) ==
VideoStreamAdapter::SetDegradationPreferenceResult::
kRestrictionsCleared) {
active_counts_.fill(VideoAdaptationCounters());
ResetActiveCounts();
encoder_stats_observer_->ClearAdaptationStats();
}
MaybeUpdateVideoSourceRestrictions();
@ -305,7 +311,7 @@ void ResourceAdaptationProcessor::SetEncoderRates(
void ResourceAdaptationProcessor::ResetVideoSourceRestrictions() {
stream_adapter_->ClearRestrictions();
active_counts_.fill(VideoAdaptationCounters());
ResetActiveCounts();
encoder_stats_observer_->ClearAdaptationStats();
MaybeUpdateVideoSourceRestrictions();
}
@ -317,12 +323,12 @@ void ResourceAdaptationProcessor::OnFrame(const VideoFrame& frame) {
void ResourceAdaptationProcessor::OnFrameDroppedDueToSize() {
VideoAdaptationCounters counters_before =
stream_adapter_->adaptation_counters();
OnResourceOveruse(AdaptationObserverInterface::AdaptReason::kQuality);
OnResourceOveruse(VideoAdaptationReason::kQuality);
if (degradation_preference() == DegradationPreference::BALANCED &&
stream_adapter_->adaptation_counters().fps_adaptations >
counters_before.fps_adaptations) {
// Adapt framerate in same step as resolution.
OnResourceOveruse(AdaptationObserverInterface::AdaptReason::kQuality);
OnResourceOveruse(VideoAdaptationReason::kQuality);
}
if (stream_adapter_->adaptation_counters().resolution_adaptations >
counters_before.resolution_adaptations) {
@ -428,8 +434,7 @@ ResourceAdaptationProcessor::OnResourceUsageStateMeasured(
RTC_DCHECK(registered_resource != resources_.end())
<< resource.name() << " not found.";
const AdaptationObserverInterface::AdaptReason reason =
registered_resource->reason;
const VideoAdaptationReason reason = registered_resource->reason;
switch (resource.usage_state()) {
case ResourceUsageState::kOveruse:
return OnResourceOveruse(reason);
@ -449,7 +454,7 @@ ResourceAdaptationProcessor::OnResourceUsageStateMeasured(
}
void ResourceAdaptationProcessor::OnResourceUnderuse(
AdaptationObserverInterface::AdaptReason reason) {
VideoAdaptationReason reason) {
// We can't adapt up if we're already at the highest setting.
// Note that this only includes counts relevant to the current degradation
// preference. e.g. we previously adapted resolution, now prefer adpating fps,
@ -489,7 +494,7 @@ void ResourceAdaptationProcessor::OnResourceUnderuse(
}
ResourceListenerResponse ResourceAdaptationProcessor::OnResourceOveruse(
AdaptationObserverInterface::AdaptReason reason) {
VideoAdaptationReason reason) {
if (!has_input_video_)
return ResourceListenerResponse::kQualityScalerShouldIncreaseFrequency;
// Update video input states and encoder settings for accurate adaptation.
@ -643,22 +648,19 @@ void ResourceAdaptationProcessor::OnAdaptationCountChanged(
RTC_DCHECK_GE(other_active->fps_adaptations, 0);
}
// TODO(nisse): Delete, once AdaptReason and AdaptationReason are merged.
void ResourceAdaptationProcessor::UpdateAdaptationStats(
AdaptationObserverInterface::AdaptReason reason) {
VideoAdaptationReason reason) {
// Update active counts
VideoAdaptationCounters& active_count = active_counts_[reason];
VideoAdaptationCounters& other_active = active_counts_[(reason + 1) % 2];
VideoAdaptationCounters& other_active = active_counts_[OtherReason(reason)];
const VideoAdaptationCounters total_counts =
stream_adapter_->adaptation_counters();
OnAdaptationCountChanged(total_counts, &active_count, &other_active);
encoder_stats_observer_->OnAdaptationChanged(
ToAdaptationReason(reason),
std::get<AdaptationObserverInterface::AdaptReason::kCpu>(active_counts_),
std::get<AdaptationObserverInterface::AdaptReason::kQuality>(
active_counts_));
reason, active_counts_[VideoAdaptationReason::kCpu],
active_counts_[VideoAdaptationReason::kQuality]);
}
void ResourceAdaptationProcessor::UpdateStatsAdaptationSettings() const {
@ -710,9 +712,9 @@ void ResourceAdaptationProcessor::MaybePerformQualityRampupExperiment() {
// TODO(https://crbug.com/webrtc/11392): See if we can rely on the total
// counts or the stats, and not the active counts.
const VideoAdaptationCounters& qp_counts =
std::get<AdaptationObserverInterface::kQuality>(active_counts_);
active_counts_[VideoAdaptationReason::kQuality];
const VideoAdaptationCounters& cpu_counts =
std::get<AdaptationObserverInterface::kCpu>(active_counts_);
active_counts_[VideoAdaptationReason::kCpu];
if (try_quality_rampup && qp_counts.resolution_adaptations > 0 &&
cpu_counts.Total() == 0) {
RTC_LOG(LS_INFO) << "Reset quality limitations.";
@ -721,18 +723,25 @@ void ResourceAdaptationProcessor::MaybePerformQualityRampupExperiment() {
}
}
void ResourceAdaptationProcessor::ResetActiveCounts() {
active_counts_.clear();
active_counts_[VideoAdaptationReason::kCpu] = VideoAdaptationCounters();
active_counts_[VideoAdaptationReason::kQuality] = VideoAdaptationCounters();
}
std::string ResourceAdaptationProcessor::ActiveCountsToString() const {
RTC_DCHECK_EQ(2, active_counts_.size());
rtc::StringBuilder ss;
ss << "Downgrade counts: fps: {";
for (size_t reason = 0; reason < active_counts_.size(); ++reason) {
ss << (reason ? " cpu" : "quality") << ":";
ss << active_counts_[reason].fps_adaptations;
for (auto& reason_count : active_counts_) {
ss << ToString(reason_count.first) << ":";
ss << reason_count.second.fps_adaptations;
}
ss << "}, resolution {";
for (size_t reason = 0; reason < active_counts_.size(); ++reason) {
ss << (reason ? " cpu" : "quality") << ":";
ss << active_counts_[reason].resolution_adaptations;
for (auto& reason_count : active_counts_) {
ss << ToString(reason_count.first) << ":";
ss << reason_count.second.resolution_adaptations;
}
ss << "}";

21
video/adaptation/resource_adaptation_processor.h
View file

@ -14,12 +14,14 @@
#include <map>
#include <memory>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
#include "absl/types/optional.h"
#include "api/rtp_parameters.h"
#include "api/video/video_adaptation_counters.h"
#include "api/video/video_adaptation_reason.h"
#include "api/video/video_frame.h"
#include "api/video/video_source_interface.h"
#include "api/video/video_stream_encoder_observer.h"
@ -78,8 +80,7 @@ class ResourceAdaptationProcessor : public ResourceAdaptationProcessorInterface,
void StopResourceAdaptation() override;
// Uses a default AdaptReason of kCpu.
void AddResource(Resource* resource) override;
void AddResource(Resource* resource,
AdaptationObserverInterface::AdaptReason reason);
void AddResource(Resource* resource, VideoAdaptationReason reason);
void SetHasInputVideo(bool has_input_video) override;
void SetDegradationPreference(
DegradationPreference degradation_preference) override;
@ -134,9 +135,8 @@ class ResourceAdaptationProcessor : public ResourceAdaptationProcessorInterface,
// Performs the adaptation by getting the next target, applying it and
// informing listeners of the new VideoSourceRestriction and adapt counters.
void OnResourceUnderuse(AdaptationObserverInterface::AdaptReason reason);
ResourceListenerResponse OnResourceOveruse(
AdaptationObserverInterface::AdaptReason reason);
void OnResourceUnderuse(VideoAdaptationReason reason);
ResourceListenerResponse OnResourceOveruse(VideoAdaptationReason reason);
CpuOveruseOptions GetCpuOveruseOptions() const;
int LastInputFrameSizeOrDefault() const;
@ -154,7 +154,7 @@ class ResourceAdaptationProcessor : public ResourceAdaptationProcessorInterface,
void UpdateQualityScalerSettings(
absl::optional<VideoEncoder::QpThresholds> qp_thresholds);
void UpdateAdaptationStats(AdaptationObserverInterface::AdaptReason reason);
void UpdateAdaptationStats(VideoAdaptationReason reason);
void UpdateStatsAdaptationSettings() const;
// Checks to see if we should execute the quality rampup experiment. The
@ -165,6 +165,7 @@ class ResourceAdaptationProcessor : public ResourceAdaptationProcessorInterface,
void MaybePerformQualityRampupExperiment();
void ResetVideoSourceRestrictions();
void ResetActiveCounts();
std::string ActiveCountsToString() const;
ResourceAdaptationProcessorListener* const adaptation_listener_;
@ -199,13 +200,12 @@ class ResourceAdaptationProcessor : public ResourceAdaptationProcessorInterface,
// Ties a resource to a reason for statistical reporting. This AdaptReason is
// also used by this module to make decisions about how to adapt up/down.
struct ResourceAndReason {
ResourceAndReason(Resource* resource,
AdaptationObserverInterface::AdaptReason reason)
ResourceAndReason(Resource* resource, VideoAdaptationReason reason)
: resource(resource), reason(reason) {}
virtual ~ResourceAndReason() = default;
Resource* const resource;
const AdaptationObserverInterface::AdaptReason reason;
const VideoAdaptationReason reason;
};
std::vector<ResourceAndReason> resources_;
// One AdaptationCounter for each reason, tracking the number of times we have
@ -215,8 +215,7 @@ class ResourceAdaptationProcessor : public ResourceAdaptationProcessorInterface,
// encoder_stats_observer_; Counters used for deciding if the video resolution
// or framerate is currently restricted, and if so, why, on a per degradation
// preference basis.
std::array<VideoAdaptationCounters,
AdaptationObserverInterface::kScaleReasonSize>
std::unordered_map<VideoAdaptationReason, VideoAdaptationCounters>
active_counts_;
};

9
video/adaptation/video_stream_adapter.cc
View file

@ -15,6 +15,7 @@
#include <utility>
#include "absl/types/optional.h"
#include "api/video/video_adaptation_reason.h"
#include "api/video_codecs/video_encoder.h"
#include "rtc_base/constructor_magic.h"
#include "rtc_base/logging.h"
@ -385,7 +386,7 @@ void VideoStreamAdapter::SetInput(
}
Adaptation VideoStreamAdapter::GetAdaptationUp(
AdaptationObserverInterface::AdaptReason reason) const {
VideoAdaptationReason reason) const {
// Don't adapt if we don't have sufficient input.
if (input_mode_ == VideoInputMode::kNoVideo) {
return Adaptation(adaptation_validation_id_,
@ -403,7 +404,7 @@ Adaptation VideoStreamAdapter::GetAdaptationUp(
}
// Don't adapt if BalancedDegradationSettings applies and determines this will
// exceed bitrate constraints.
if (reason == AdaptationObserverInterface::AdaptReason::kQuality &&
if (reason == VideoAdaptationReason::kQuality &&
EffectiveDegradationPreference() == DegradationPreference::BALANCED &&
!balanced_settings_.CanAdaptUp(
GetVideoCodecTypeOrGeneric(encoder_settings_), input_pixels_,
@ -426,7 +427,7 @@ Adaptation VideoStreamAdapter::GetAdaptationUp(
}
// Fall-through to maybe-adapting resolution, unless |balanced_settings_|
// forbids it based on bitrate.
if (reason == AdaptationObserverInterface::AdaptReason::kQuality &&
if (reason == VideoAdaptationReason::kQuality &&
!balanced_settings_.CanAdaptUpResolution(
GetVideoCodecTypeOrGeneric(encoder_settings_), input_pixels_,
encoder_target_bitrate_bps_.value_or(0))) {
@ -439,7 +440,7 @@ Adaptation VideoStreamAdapter::GetAdaptationUp(
case DegradationPreference::MAINTAIN_FRAMERATE: {
// Don't adapt resolution if CanAdaptUpResolution() forbids it based on
// bitrate and limits specified by encoder capabilities.
if (reason == AdaptationObserverInterface::AdaptReason::kQuality &&
if (reason == VideoAdaptationReason::kQuality &&
!CanAdaptUpResolution(encoder_settings_, encoder_target_bitrate_bps_,
input_pixels_)) {
return Adaptation(adaptation_validation_id_,

4
video/adaptation/video_stream_adapter.h
View file

@ -16,6 +16,7 @@
#include "absl/types/optional.h"
#include "api/rtp_parameters.h"
#include "api/video/video_adaptation_counters.h"
#include "api/video/video_adaptation_reason.h"
#include "call/adaptation/encoder_settings.h"
#include "call/adaptation/resource.h"
#include "call/adaptation/video_source_restrictions.h"
@ -160,8 +161,7 @@ class VideoStreamAdapter {
// Returns an adaptation that we are guaranteed to be able to apply, or a
// status code indicating the reason why we cannot adapt.
Adaptation GetAdaptationUp(
AdaptationObserverInterface::AdaptReason reason) const;
Adaptation GetAdaptationUp(VideoAdaptationReason reason) const;
Adaptation GetAdaptationDown() const;
// Returns the restrictions that result from applying the adaptation, without
// actually applying it. If the adaptation is not valid, current restrictions

10
video/adaptation/video_stream_adapter_unittest.cc
View file

@ -14,6 +14,7 @@
#include <utility>
#include "absl/types/optional.h"
#include "api/video/video_adaptation_reason.h"
#include "api/video_codecs/video_codec.h"
#include "api/video_codecs/video_encoder.h"
#include "api/video_codecs/video_encoder_config.h"
@ -31,7 +32,7 @@ namespace {
// GetAdaptationUp() requires an AdaptReason. This is only used in edge cases,
// so most tests don't care what reason is used.
const auto kReasonDontCare = AdaptationObserverInterface::AdaptReason::kQuality;
const auto kReasonDontCare = VideoAdaptationReason::kQuality;
const int kBalancedHighResolutionPixels = 1280 * 720;
const int kBalancedHighFrameRateFps = 30;
@ -636,11 +637,8 @@ TEST(VideoStreamAdapterTest, BitrateConstrained_MaintainFramerate) {
// TODO(hbos): Why would the reason matter? If the signal was kCpu then the
// current code allows us to violate this bitrate constraint. This does not
// make any sense: either we are limited or we are not, end of story.
EXPECT_EQ(
Adaptation::Status::kIsBitrateConstrained,
adapter
.GetAdaptationUp(AdaptationObserverInterface::AdaptReason::kQuality)
.status());
EXPECT_EQ(Adaptation::Status::kIsBitrateConstrained,
adapter.GetAdaptationUp(VideoAdaptationReason::kQuality).status());
}
TEST(VideoStreamAdapterTest, PeekNextRestrictions) {

6
video/send_statistics_proxy.cc
View file

@ -1098,7 +1098,7 @@ void SendStatisticsProxy::UpdateAdaptationSettings(
}
void SendStatisticsProxy::OnAdaptationChanged(
AdaptationReason reason,
VideoAdaptationReason reason,
const VideoAdaptationCounters& cpu_counters,
const VideoAdaptationCounters& quality_counters) {
rtc::CritScope lock(&crit_);
@ -1107,10 +1107,10 @@ void SendStatisticsProxy::OnAdaptationChanged(
adaptations_.set_cpu_counts(cpu_counters);
adaptations_.set_quality_counts(quality_counters);
switch (reason) {
case AdaptationReason::kCpu:
case VideoAdaptationReason::kCpu:
++stats_.number_of_cpu_adapt_changes;
break;
case AdaptationReason::kQuality:
case VideoAdaptationReason::kQuality:
TryUpdateInitialQualityResolutionAdaptUp(
receiver.resolution_adaptations,
adaptations_.MaskedQualityCounts().resolution_adaptations);

2
video/send_statistics_proxy.h
View file

@ -71,7 +71,7 @@ class SendStatisticsProxy : public VideoStreamEncoderObserver,
// Adaptation stats.
void OnAdaptationChanged(
AdaptationReason reason,
VideoAdaptationReason reason,
const VideoAdaptationCounters& cpu_counters,
const VideoAdaptationCounters& quality_counters) override;
void ClearAdaptationStats() override;

306
video/send_statistics_proxy_unittest.cc
View file

@ -18,6 +18,7 @@
#include "absl/algorithm/container.h"
#include "api/units/timestamp.h"
#include "api/video/video_adaptation_reason.h"
#include "api/video/video_bitrate_allocation.h"
#include "api/video/video_codec_type.h"
#include "api/video_codecs/video_codec.h"
@ -449,31 +450,27 @@ TEST_F(SendStatisticsProxyTest, GetCpuAdaptationStats) {
cpu_counts.fps_adaptations = 1;
cpu_counts.resolution_adaptations = 0;
statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
EXPECT_TRUE(statistics_proxy_->GetStats().cpu_limited_framerate);
EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_resolution);
cpu_counts.fps_adaptations = 0;
cpu_counts.resolution_adaptations = 1;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_framerate);
EXPECT_TRUE(statistics_proxy_->GetStats().cpu_limited_resolution);
cpu_counts.fps_adaptations = 1;
statistics_proxy_->UpdateAdaptationSettings(kResolutionScalingDisabled,
kResolutionScalingDisabled);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
EXPECT_TRUE(statistics_proxy_->GetStats().cpu_limited_framerate);
EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_resolution);
statistics_proxy_->UpdateAdaptationSettings(kScalingDisabled,
kScalingDisabled);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_framerate);
EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_resolution);
}
@ -486,31 +483,27 @@ TEST_F(SendStatisticsProxyTest, GetQualityAdaptationStats) {
quality_counts.fps_adaptations = 1;
quality_counts.resolution_adaptations = 0;
statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_framerate);
EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
quality_counts.fps_adaptations = 0;
quality_counts.resolution_adaptations = 1;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_framerate);
EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_resolution);
quality_counts.fps_adaptations = 1;
statistics_proxy_->UpdateAdaptationSettings(kResolutionScalingDisabled,
kResolutionScalingDisabled);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_framerate);
EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
statistics_proxy_->UpdateAdaptationSettings(kScalingDisabled,
kScalingDisabled);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_framerate);
EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
}
@ -522,17 +515,15 @@ TEST_F(SendStatisticsProxyTest, GetStatsReportsCpuAdaptChanges) {
EXPECT_EQ(0, statistics_proxy_->GetStats().number_of_cpu_adapt_changes);
cpu_counts.resolution_adaptations = 1;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_framerate);
EXPECT_TRUE(statistics_proxy_->GetStats().cpu_limited_resolution);
EXPECT_EQ(1, statistics_proxy_->GetStats().number_of_cpu_adapt_changes);
cpu_counts.resolution_adaptations = 2;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
EXPECT_FALSE(statistics_proxy_->GetStats().cpu_limited_framerate);
EXPECT_TRUE(statistics_proxy_->GetStats().cpu_limited_resolution);
EXPECT_EQ(2, statistics_proxy_->GetStats().number_of_cpu_adapt_changes);
@ -546,17 +537,15 @@ TEST_F(SendStatisticsProxyTest, GetStatsReportsQualityAdaptChanges) {
EXPECT_EQ(0, statistics_proxy_->GetStats().number_of_quality_adapt_changes);
quality_counts.fps_adaptations = 1;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_framerate);
EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
EXPECT_EQ(1, statistics_proxy_->GetStats().number_of_quality_adapt_changes);
quality_counts.fps_adaptations = 0;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_framerate);
EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);
EXPECT_EQ(2, statistics_proxy_->GetStats().number_of_quality_adapt_changes);
@ -571,21 +560,17 @@ TEST_F(SendStatisticsProxyTest, TestAdaptationStatisticsMasking) {
EXPECT_EQ(0, statistics_proxy_->GetStats().number_of_cpu_adapt_changes);
quality_counts.resolution_adaptations = 1;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
quality_counts.fps_adaptations = 1;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
cpu_counts.resolution_adaptations = 1;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
cpu_counts.fps_adaptations = 1;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
// We have 1 fps and resolution reduction for both cpu and quality
EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_framerate);
EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_resolution);
@ -686,9 +671,8 @@ TEST_F(SendStatisticsProxyTest, CpuAdaptChangesReported) {
VideoAdaptationCounters quality_counts;
statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
// Adapt changes: 1, elapsed time: 10 sec => 6 per minute.
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
fake_clock_.AdvanceTimeMilliseconds(10000);
statistics_proxy_.reset();
EXPECT_METRIC_EQ(
@ -705,9 +689,8 @@ TEST_F(SendStatisticsProxyTest, ExcludesInitialQualityAdaptDownChange) {
VideoAdaptationCounters quality_counts;
statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
// Adapt changes: 1 (1 initial) = 0, elapsed time: 10 sec => 0 per minute.
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
statistics_proxy_->OnInitialQualityResolutionAdaptDown();
fake_clock_.AdvanceTimeMilliseconds(10000);
statistics_proxy_.reset();
@ -726,19 +709,16 @@ TEST_F(SendStatisticsProxyTest, ExcludesInitialQualityAdaptDownChanges) {
statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
// Adapt changes: 3 (2 initial) = 1, elapsed time: 10 sec => 6 per minute.
quality_counts.resolution_adaptations = 1;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
statistics_proxy_->OnInitialQualityResolutionAdaptDown();
quality_counts.resolution_adaptations = 2;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
statistics_proxy_->OnInitialQualityResolutionAdaptDown();
quality_counts.resolution_adaptations = 3;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
fake_clock_.AdvanceTimeMilliseconds(10000);
statistics_proxy_.reset();
EXPECT_METRIC_EQ(
@ -755,9 +735,8 @@ TEST_F(SendStatisticsProxyTest, InitialQualityAdaptChangesNotExcludedOnError) {
VideoAdaptationCounters quality_counts;
statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
// Adapt changes: 1 (2 initial) = 1, elapsed time: 10 sec => 6 per minute.
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
statistics_proxy_->OnInitialQualityResolutionAdaptDown();
statistics_proxy_->OnInitialQualityResolutionAdaptDown();
fake_clock_.AdvanceTimeMilliseconds(10000);
@ -778,39 +757,31 @@ TEST_F(SendStatisticsProxyTest, ExcludesInitialQualityAdaptDownAndUpChanges) {
statistics_proxy_->ClearAdaptationStats();
// Adapt changes: 8 (4 initial) = 4, elapsed time: 10 sec => 24 per minute.
quality_counts.resolution_adaptations = 1;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
statistics_proxy_->OnInitialQualityResolutionAdaptDown();
quality_counts.resolution_adaptations = 2;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
statistics_proxy_->OnInitialQualityResolutionAdaptDown();
quality_counts.resolution_adaptations = 3;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
quality_counts.fps_adaptations = 1;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
quality_counts.fps_adaptations = 0;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
quality_counts.resolution_adaptations = 2; // Initial resolution up.
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
quality_counts.resolution_adaptations = 1; // Initial resolution up.
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
quality_counts.resolution_adaptations = 0;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
fake_clock_.AdvanceTimeMilliseconds(10000);
statistics_proxy_.reset();
@ -840,13 +811,11 @@ TEST_F(SendStatisticsProxyTest, AdaptChangesStatsExcludesDisabledTime) {
statistics_proxy_->UpdateAdaptationSettings(kResolutionScalingDisabled,
kResolutionScalingDisabled);
fake_clock_.AdvanceTimeMilliseconds(9000);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
fake_clock_.AdvanceTimeMilliseconds(6000);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
// Disable quality adaptation.
statistics_proxy_->UpdateAdaptationSettings(kScalingDisabled,
@ -858,9 +827,8 @@ TEST_F(SendStatisticsProxyTest, AdaptChangesStatsExcludesDisabledTime) {
quality_counts.resolution_adaptations = 0;
statistics_proxy_->UpdateAdaptationSettings(kFramerateScalingDisabled,
kFramerateScalingDisabled);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
fake_clock_.AdvanceTimeMilliseconds(10000);
// Disable quality adaptation.
@ -908,12 +876,10 @@ TEST_F(SendStatisticsProxyTest, QualityAdaptChangesStatsExcludesSuspendedTime) {
// Adapt changes: 2, elapsed time: 20 sec.
statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
fake_clock_.AdvanceTimeMilliseconds(20000);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
// Suspend and resume video.
statistics_proxy_->OnSuspendChange(true);
@ -921,9 +887,8 @@ TEST_F(SendStatisticsProxyTest, QualityAdaptChangesStatsExcludesSuspendedTime) {
statistics_proxy_->OnSuspendChange(false);
// Adapt changes: 1, elapsed time: 10 sec.
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
fake_clock_.AdvanceTimeMilliseconds(10000);
// Adapt changes: 3, elapsed time: 30 sec => 6 per minute.
@ -948,9 +913,8 @@ TEST_F(SendStatisticsProxyTest, CpuAdaptChangesStatsExcludesSuspendedTime) {
// Adapt changes: 1, elapsed time: 20 sec.
statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
fake_clock_.AdvanceTimeMilliseconds(10000);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
// Video not suspended, stats time already started.
statistics_proxy_->OnSuspendChange(false);
@ -973,9 +937,8 @@ TEST_F(SendStatisticsProxyTest, CpuAdaptChangesStatsExcludesSuspendedTime) {
cpu_counts.resolution_adaptations = 0;
statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
fake_clock_.AdvanceTimeMilliseconds(10000);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
// Adapt changes: 2, elapsed time: 30 sec => 4 per minute.
statistics_proxy_.reset();
@ -1002,9 +965,8 @@ TEST_F(SendStatisticsProxyTest, AdaptChangesStatsNotStartedIfVideoSuspended) {
// Adapt changes: 1, elapsed time: 10 sec.
statistics_proxy_->OnSuspendChange(false);
fake_clock_.AdvanceTimeMilliseconds(10000);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
// Adapt changes: 1, elapsed time: 10 sec => 6 per minute.
statistics_proxy_.reset();
@ -1025,9 +987,8 @@ TEST_F(SendStatisticsProxyTest, AdaptChangesStatsRestartsOnFirstSentPacket) {
// Adapt changes: 1, elapsed time: 10 sec.
fake_clock_.AdvanceTimeMilliseconds(10000);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
UpdateDataCounters(kFirstSsrc);
// Adapt changes: 1, elapsed time: 10 sec => 6 per minute.
@ -1061,9 +1022,8 @@ TEST_F(SendStatisticsProxyTest, AdaptChangesStatsStartedAfterFirstSentPacket) {
// Adapt changes: 1, elapsed time: 20 sec.
fake_clock_.AdvanceTimeMilliseconds(10000);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
// Adapt changes: 1, elapsed time: 20 sec => 3 per minute.
statistics_proxy_.reset();
@ -1082,13 +1042,11 @@ TEST_F(SendStatisticsProxyTest, AdaptChangesReportedAfterContentSwitch) {
kScalingDisabled);
// Adapt changes: 2, elapsed time: 15 sec => 8 per minute.
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
fake_clock_.AdvanceTimeMilliseconds(6000);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
fake_clock_.AdvanceTimeMilliseconds(9000);
// Switch content type, real-time stats should be updated.
@ -1108,18 +1066,14 @@ TEST_F(SendStatisticsProxyTest, AdaptChangesReportedAfterContentSwitch) {
kScalingDisabled);
// Adapt changes: 4, elapsed time: 120 sec => 2 per minute.
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
fake_clock_.AdvanceTimeMilliseconds(120000);
statistics_proxy_.reset();
@ -1141,9 +1095,8 @@ TEST_F(SendStatisticsProxyTest,
cpu_counts.resolution_adaptations = 1;
statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
EXPECT_EQ(QualityLimitationReason::kCpu,
statistics_proxy_->GetStats().quality_limitation_reason);
@ -1157,9 +1110,8 @@ TEST_F(SendStatisticsProxyTest,
cpu_counts.fps_adaptations = 1;
statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
EXPECT_EQ(QualityLimitationReason::kCpu,
statistics_proxy_->GetStats().quality_limitation_reason);
@ -1173,9 +1125,8 @@ TEST_F(SendStatisticsProxyTest,
quality_counts.resolution_adaptations = 1;
statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
EXPECT_EQ(QualityLimitationReason::kBandwidth,
statistics_proxy_->GetStats().quality_limitation_reason);
@ -1189,9 +1140,8 @@ TEST_F(SendStatisticsProxyTest,
quality_counts.fps_adaptations = 1;
statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
EXPECT_EQ(QualityLimitationReason::kBandwidth,
statistics_proxy_->GetStats().quality_limitation_reason);
@ -1208,9 +1158,8 @@ TEST_F(SendStatisticsProxyTest,
// Even if the last adaptation reason is kCpu, if the counters indicate being
// both CPU and quality (=bandwidth) limited, kBandwidth takes precedence.
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
EXPECT_EQ(QualityLimitationReason::kBandwidth,
statistics_proxy_->GetStats().quality_limitation_reason);
@ -1224,14 +1173,12 @@ TEST_F(SendStatisticsProxyTest, QualityLimitationReasonIsNoneWhenNotLimited) {
// due to "none" being the default value.
cpu_counts.resolution_adaptations = 1;
statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
// Go back to not being limited.
cpu_counts.resolution_adaptations = 0;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
EXPECT_EQ(QualityLimitationReason::kNone,
statistics_proxy_->GetStats().quality_limitation_reason);
@ -1246,23 +1193,20 @@ TEST_F(SendStatisticsProxyTest, QualityLimitationDurationIncreasesWithTime) {
fake_clock_.AdvanceTimeMilliseconds(3000);
// CPU limited for 2000 ms
cpu_counts.resolution_adaptations = 1;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
fake_clock_.AdvanceTimeMilliseconds(2000);
// Bandwidth limited for 1000 ms
cpu_counts.resolution_adaptations = 0;
quality_counts.resolution_adaptations = 1;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
fake_clock_.AdvanceTimeMilliseconds(1000);
// CPU limited for another 2000 ms
cpu_counts.resolution_adaptations = 1;
quality_counts.resolution_adaptations = 0;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
fake_clock_.AdvanceTimeMilliseconds(2000);
auto quality_limitation_durations_ms =
@ -1687,9 +1631,8 @@ TEST_F(SendStatisticsProxyTest, CpuLimitedHistogramUpdated) {
statistics_proxy_->OnIncomingFrame(kWidth, kHeight);
cpu_counts.resolution_adaptations = 1;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kCpu, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kCpu,
cpu_counts, quality_counts);
for (int i = 0; i < SendStatisticsProxy::kMinRequiredMetricsSamples; ++i)
statistics_proxy_->OnIncomingFrame(kWidth, kHeight);
@ -2110,9 +2053,8 @@ TEST_F(SendStatisticsProxyTest,
VideoAdaptationCounters quality_counts;
quality_counts.resolution_adaptations = kDownscales;
statistics_proxy_->UpdateAdaptationSettings(kScalingEnabled, kScalingEnabled);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
EncodedImage encoded_image;
encoded_image.SetSpatialIndex(0);
for (int i = 0; i < SendStatisticsProxy::kMinRequiredMetricsSamples; ++i)
@ -2159,17 +2101,15 @@ TEST_F(SendStatisticsProxyTest, GetStatsReportsBandwidthLimitedResolution) {
quality_counts.resolution_adaptations = 1;
statistics_proxy_->UpdateAdaptationSettings(kFramerateScalingDisabled,
kFramerateScalingDisabled);
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
EXPECT_TRUE(statistics_proxy_->GetStats().bw_limited_resolution);
// Adapt up.
quality_counts.resolution_adaptations = 0;
statistics_proxy_->OnAdaptationChanged(
VideoStreamEncoderObserver::AdaptationReason::kQuality, cpu_counts,
quality_counts);
statistics_proxy_->OnAdaptationChanged(VideoAdaptationReason::kQuality,
cpu_counts, quality_counts);
statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
EXPECT_FALSE(statistics_proxy_->GetStats().bw_limited_resolution);

3
video/video_stream_encoder.cc
View file

@ -21,6 +21,7 @@
#include "absl/types/optional.h"
#include "api/video/encoded_image.h"
#include "api/video/i420_buffer.h"
#include "api/video/video_adaptation_reason.h"
#include "api/video/video_bitrate_allocator_factory.h"
#include "api/video/video_codec_constants.h"
#include "api/video_codecs/video_encoder.h"
@ -1917,7 +1918,7 @@ void VideoStreamEncoder::CheckForAnimatedContent(
}
void VideoStreamEncoder::InjectAdaptationResource(
Resource* resource,
AdaptationObserverInterface::AdaptReason reason) {
VideoAdaptationReason reason) {
resource_adaptation_processor_->AddResource(resource, reason);
}

2
video/video_stream_encoder.h
View file

@ -112,7 +112,7 @@ class VideoStreamEncoder : public VideoStreamEncoderInterface,
// Used for injected test resources.
// TODO(eshr): Move all adaptation tests out of VideoStreamEncoder tests.
void InjectAdaptationResource(Resource* resource,
AdaptationObserverInterface::AdaptReason reason)
VideoAdaptationReason reason)
RTC_RUN_ON(&encoder_queue_);
private:

36
video/video_stream_encoder_unittest.cc
View file

@ -21,6 +21,7 @@
#include "api/test/mock_video_encoder.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "api/video/i420_buffer.h"
#include "api/video/video_adaptation_reason.h"
#include "api/video/video_bitrate_allocation.h"
#include "api/video_codecs/video_encoder.h"
#include "api/video_codecs/vp8_temporal_layers.h"
@ -48,7 +49,7 @@
namespace webrtc {
using ScaleReason = AdaptationObserverInterface::AdaptReason;
using ScaleReason = VideoAdaptationReason;
using ::testing::_;
using ::testing::AllOf;
using ::testing::Field;
@ -164,20 +165,18 @@ class VideoStreamEncoderUnderTest : public VideoStreamEncoder {
fake_quality_resource_(
std::make_unique<FakeResource>(ResourceUsageState::kStable,
"FakeResource[QP]")) {
InjectAdaptationResource(
fake_quality_resource_.get(),
AdaptationObserverInterface::AdaptReason::kQuality);
InjectAdaptationResource(fake_quality_resource_.get(),
VideoAdaptationReason::kQuality);
InjectAdaptationResource(fake_cpu_resource_.get(),
AdaptationObserverInterface::AdaptReason::kCpu);
VideoAdaptationReason::kCpu);
}
void PostTaskAndWait(bool down,
AdaptationObserverInterface::AdaptReason reason) {
void PostTaskAndWait(bool down, VideoAdaptationReason reason) {
PostTaskAndWait(down, reason, /*expected_results=*/true);
}
void PostTaskAndWait(bool down,
AdaptationObserverInterface::AdaptReason reason,
VideoAdaptationReason reason,
bool expected_results) {
rtc::Event event;
encoder_queue()->PostTask([this, &event, reason, down, expected_results] {
@ -186,10 +185,10 @@ class VideoStreamEncoderUnderTest : public VideoStreamEncoder {
FakeResource* resource = nullptr;
switch (reason) {
case AdaptationObserverInterface::kQuality:
case VideoAdaptationReason::kQuality:
resource = fake_quality_resource_.get();
break;
case AdaptationObserverInterface::kCpu:
case VideoAdaptationReason::kCpu:
resource = fake_cpu_resource_.get();
break;
default:
@ -198,7 +197,7 @@ class VideoStreamEncoderUnderTest : public VideoStreamEncoder {
resource->set_usage_state(usage_state);
if (!expected_results) {
ASSERT_EQ(AdaptationObserverInterface::kQuality, reason)
ASSERT_EQ(VideoAdaptationReason::kQuality, reason)
<< "We can only assert adaptation result for quality resources";
EXPECT_EQ(
ResourceListenerResponse::kQualityScalerShouldIncreaseFrequency,
@ -222,29 +221,24 @@ class VideoStreamEncoderUnderTest : public VideoStreamEncoder {
}
void TriggerCpuOveruse() {
PostTaskAndWait(/*down=*/true,
AdaptationObserverInterface::AdaptReason::kCpu);
PostTaskAndWait(/*down=*/true, VideoAdaptationReason::kCpu);
}
void TriggerCpuNormalUsage() {
PostTaskAndWait(/*down=*/false,
AdaptationObserverInterface::AdaptReason::kCpu);
PostTaskAndWait(/*down=*/false, VideoAdaptationReason::kCpu);
}
void TriggerQualityLow() {
PostTaskAndWait(/*down=*/true,
AdaptationObserverInterface::AdaptReason::kQuality);
PostTaskAndWait(/*down=*/true, VideoAdaptationReason::kQuality);
}
void TriggerQualityLowExpectFalse() {
PostTaskAndWait(/*down=*/true,
AdaptationObserverInterface::AdaptReason::kQuality,
PostTaskAndWait(/*down=*/true, VideoAdaptationReason::kQuality,
/*expected_results=*/false);
}
void TriggerQualityHigh() {
PostTaskAndWait(/*down=*/false,
AdaptationObserverInterface::AdaptReason::kQuality);
PostTaskAndWait(/*down=*/false, VideoAdaptationReason::kQuality);
}
CpuOveruseDetectorProxy* overuse_detector_proxy_;