Merge changes from topic "deprecate-content-detection-v1" (fc50f74c) · Commits · e / os / platform_frameworks_native

services/surfaceflinger/Android.bp

+0 −2

Original line number	Diff line number	Diff line
		@@ -156,9 +156,7 @@ filegroup {
		"Scheduler/EventThread.cpp",
		"Scheduler/OneShotTimer.cpp",
		"Scheduler/LayerHistory.cpp",
		"Scheduler/LayerHistoryV2.cpp",
		"Scheduler/LayerInfo.cpp",
		"Scheduler/LayerInfoV2.cpp",
		"Scheduler/MessageQueue.cpp",
		"Scheduler/RefreshRateConfigs.cpp",
		"Scheduler/Scheduler.cpp",

services/surfaceflinger/Scheduler/LayerHistory.cpp

+86 −67

Original line number	Diff line number	Diff line
		/*
		* Copyright 2018 The Android Open Source Project
		* Copyright 2020 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		@@ -35,21 +35,21 @@
		#include "LayerInfo.h"
		#include "SchedulerUtils.h"

		namespace android::scheduler::impl {
		namespace android::scheduler {

		namespace {

		bool isLayerActive(const Layer& layer, const LayerInfo& info, nsecs_t threshold) {
		// Layers with an explicit vote are always kept active
		if (layer.getFrameRateForLayerTree().rate > 0) {
		return layer.isVisible();
		return true;
		}

		return layer.isVisible() && info.getLastUpdatedTime() >= threshold;
		}

		bool traceEnabled() {
		char value[PROPERTY_VALUE_MAX];
		property_get("debug.sf.layer_history_trace", value, "0");
		return atoi(value);
		return property_get_bool("debug.sf.layer_history_trace", false);
		}

		bool useFrameRatePriority() {
		@@ -58,30 +58,44 @@ bool useFrameRatePriority() {
		return atoi(value);
		}

		void trace(const wp<Layer>& weak, int fps) {
		void trace(const wp<Layer>& weak, const LayerInfo& info, LayerHistory::LayerVoteType type,
		int fps) {
		const auto layer = weak.promote();
		if (!layer) return;

		const auto& name = layer->getName();
		const auto tag = "LFPS " + name;
		ATRACE_INT(tag.c_str(), fps);
		ALOGD("%s: %s @ %d Hz", __FUNCTION__, name.c_str(), fps);
		const auto traceType = [&](LayerHistory::LayerVoteType checkedType, int value) {
		ATRACE_INT(info.getTraceTag(checkedType), type == checkedType ? value : 0);
		};

		traceType(LayerHistory::LayerVoteType::NoVote, 1);
		traceType(LayerHistory::LayerVoteType::Heuristic, fps);
		traceType(LayerHistory::LayerVoteType::ExplicitDefault, fps);
		traceType(LayerHistory::LayerVoteType::ExplicitExactOrMultiple, fps);
		traceType(LayerHistory::LayerVoteType::Min, 1);
		traceType(LayerHistory::LayerVoteType::Max, 1);

		ALOGD("%s: %s @ %d Hz", __FUNCTION__, layer->getName().c_str(), fps);
		}
		} // namespace

		LayerHistory::LayerHistory()
		: mTraceEnabled(traceEnabled()), mUseFrameRatePriority(useFrameRatePriority()) {}
		LayerHistory::LayerHistory(const RefreshRateConfigs& refreshRateConfigs)
		: mTraceEnabled(traceEnabled()), mUseFrameRatePriority(useFrameRatePriority()) {
		LayerInfo::setTraceEnabled(mTraceEnabled);
		LayerInfo::setRefreshRateConfigs(refreshRateConfigs);
		}

		LayerHistory::~LayerHistory() = default;

		void LayerHistory::registerLayer(Layer* layer, float lowRefreshRate, float highRefreshRate,
		LayerVoteType /type/) {
		auto info = std::make_unique<LayerInfo>(lowRefreshRate, highRefreshRate);
		void LayerHistory::registerLayer(Layer* layer, float /lowRefreshRate/, float highRefreshRate,
		LayerVoteType type) {
		const nsecs_t highRefreshRatePeriod = static_cast<nsecs_t>(1e9f / highRefreshRate);
		auto info = std::make_unique<LayerInfo>(layer->getName(), highRefreshRatePeriod, type);
		std::lock_guard lock(mLock);
		mLayerInfos.emplace_back(layer, std::move(info));
		}

		void LayerHistory::record(Layer* layer, nsecs_t presentTime, nsecs_t now,
		LayerUpdateType /updateType/) {
		LayerUpdateType updateType) {
		std::lock_guard lock(mLock);

		const auto it = std::find_if(mLayerInfos.begin(), mLayerInfos.end(),
		@@ -89,7 +103,7 @@ void LayerHistory::record(Layer* layer, nsecs_t presentTime, nsecs_t now,
		LOG_FATAL_IF(it == mLayerInfos.end(), "%s: unknown layer %p", __FUNCTION__, layer);

		const auto& info = it->second;
		info->setLastPresentTime(presentTime, now);
		info->setLastPresentTime(presentTime, now, updateType, mConfigChangePending);

		// Activate layer if inactive.
		if (const auto end = activeLayers().end(); it >= end) {
		@@ -99,54 +113,42 @@ void LayerHistory::record(Layer* layer, nsecs_t presentTime, nsecs_t now,
		}

		LayerHistory::Summary LayerHistory::summarize(nsecs_t now) {
		ATRACE_CALL();
		LayerHistory::Summary summary;

		std::lock_guard lock(mLock);

		partitionLayers(now);

		LayerHistory::Summary summary;
		for (const auto& [weakLayer, info] : activeLayers()) {
		const bool recent = info->isRecentlyActive(now);
		auto layer = weakLayer.promote();
		// Only use the layer if the reference still exists.
		if (layer \|\| CC_UNLIKELY(mTraceEnabled)) {
		const auto layerFocused =
		Layer::isLayerFocusedBasedOnPriority(layer->getFrameRateSelectionPriority());
		// Check if frame rate was set on layer.
		const auto frameRate = layer->getFrameRateForLayerTree();
		if (frameRate.rate > 0.f) {
		const auto voteType = [&]() {
		switch (frameRate.type) {
		case Layer::FrameRateCompatibility::Default:
		return LayerVoteType::ExplicitDefault;
		case Layer::FrameRateCompatibility::ExactOrMultiple:
		return LayerVoteType::ExplicitExactOrMultiple;
		case Layer::FrameRateCompatibility::NoVote:
		return LayerVoteType::NoVote;
		for (const auto& [layer, info] : activeLayers()) {
		const auto strong = layer.promote();
		if (!strong) {
		continue;
		}
		}();
		summary.push_back(
		RefreshRateConfigs::LayerRequirement{.name = layer->getName(),
		.vote = voteType,
		.desiredRefreshRate = frameRate.rate,
		.seamlessness = frameRate.seamlessness,
		.weight = 1.0f,
		.focused = layerFocused});
		} else if (recent) {
		summary.push_back(
		RefreshRateConfigs::LayerRequirement{.name = layer->getName(),
		.vote = LayerVoteType::Heuristic,
		.desiredRefreshRate =
		info->getRefreshRate(now),
		.seamlessness =
		Seamlessness::OnlySeamless,
		.weight = 1.0f,
		.focused = layerFocused});

		const auto frameRateSelectionPriority = strong->getFrameRateSelectionPriority();
		const auto layerFocused = Layer::isLayerFocusedBasedOnPriority(frameRateSelectionPriority);
		ALOGV("%s has priority: %d %s focused", strong->getName().c_str(),
		frameRateSelectionPriority, layerFocused ? "" : "not");

		const auto vote = info->getRefreshRateVote(now);
		// Skip NoVote layer as those don't have any requirements
		if (vote.type == LayerHistory::LayerVoteType::NoVote) {
		continue;
		}

		// Compute the layer's position on the screen
		const Rect bounds = Rect(strong->getBounds());
		const ui::Transform transform = strong->getTransform();
		constexpr bool roundOutwards = true;
		Rect transformed = transform.transform(bounds, roundOutwards);

		const float layerArea = transformed.getWidth() * transformed.getHeight();
		float weight = mDisplayArea ? layerArea / mDisplayArea : 0.0f;
		summary.push_back(
		{strong->getName(), vote.type, vote.fps, vote.seamlessness, weight, layerFocused});

		if (CC_UNLIKELY(mTraceEnabled)) {
		trace(weakLayer, round<int>(frameRate.rate));
		}
		trace(layer, *info, vote.type, static_cast<int>(std::round(vote.fps)));
		}
		}

		@@ -162,14 +164,33 @@ void LayerHistory::partitionLayers(nsecs_t now) {
		auto& [weak, info] = mLayerInfos[i];
		if (const auto layer = weak.promote(); layer && isLayerActive(layer, info, threshold)) {
		i++;
		// Set layer vote if set
		const auto frameRate = layer->getFrameRateForLayerTree();
		const auto voteType = [&]() {
		switch (frameRate.type) {
		case Layer::FrameRateCompatibility::Default:
		return LayerVoteType::ExplicitDefault;
		case Layer::FrameRateCompatibility::ExactOrMultiple:
		return LayerVoteType::ExplicitExactOrMultiple;
		case Layer::FrameRateCompatibility::NoVote:
		return LayerVoteType::NoVote;
		}
		}();

		if (frameRate.rate > 0 \|\| voteType == LayerVoteType::NoVote) {
		const auto type = layer->isVisible() ? voteType : LayerVoteType::NoVote;
		info->setLayerVote({type, frameRate.rate, frameRate.seamlessness});
		} else {
		info->resetLayerVote();
		}
		continue;
		}

		if (CC_UNLIKELY(mTraceEnabled)) {
		trace(weak, 0);
		trace(weak, *info, LayerHistory::LayerVoteType::NoVote, 0);
		}

		info->clearHistory();
		info->onLayerInactive(now);
		std::swap(mLayerInfos[i], mLayerInfos[--mActiveLayersEnd]);
		}

		@@ -190,10 +211,8 @@ void LayerHistory::clear() {
		std::lock_guard lock(mLock);

		for (const auto& [layer, info] : activeLayers()) {
		info->clearHistory();
		info->clearHistory(systemTime());
		}

		mActiveLayersEnd = 0;
		}

		std::string LayerHistory::dump() const {
		@@ -202,4 +221,4 @@ std::string LayerHistory::dump() const {
		mActiveLayersEnd);
		}

		} // namespace android::scheduler::impl
		} // namespace android::scheduler

services/surfaceflinger/Scheduler/LayerHistory.h

+10 −99

Original line number	Diff line number	Diff line
		@@ -36,25 +36,23 @@ class TestableScheduler;
		namespace scheduler {

		class LayerHistoryTest;
		class LayerHistoryTestV2;
		class LayerInfo;
		class LayerInfoV2;

		class LayerHistory {
		public:
		using LayerVoteType = RefreshRateConfigs::LayerVoteType;

		virtual ~LayerHistory() = default;
		LayerHistory(const RefreshRateConfigs&);
		~LayerHistory();

		// Layers are unregistered when the weak reference expires.
		virtual void registerLayer(Layer*, float lowRefreshRate, float highRefreshRate,
		LayerVoteType type) = 0;
		void registerLayer(Layer*, float lowRefreshRate, float highRefreshRate, LayerVoteType type);

		// Sets the display size. Client is responsible for synchronization.
		virtual void setDisplayArea(uint32_t displayArea) = 0;
		void setDisplayArea(uint32_t displayArea) { mDisplayArea = displayArea; }

		// Sets whether a config change is pending to be applied
		virtual void setConfigChangePending(bool pending) = 0;
		void setConfigChangePending(bool pending) { mConfigChangePending = pending; }

		// Represents which layer activity is recorded
		enum class LayerUpdateType {
		@@ -64,45 +62,18 @@ public:
		};

		// Marks the layer as active, and records the given state to its history.
		virtual void record(Layer*, nsecs_t presentTime, nsecs_t now, LayerUpdateType updateType) = 0;
		void record(Layer*, nsecs_t presentTime, nsecs_t now, LayerUpdateType updateType);

		using Summary = std::vector<RefreshRateConfigs::LayerRequirement>;

		// Rebuilds sets of active/inactive layers, and accumulates stats for active layers.
		virtual Summary summarize(nsecs_t now) = 0;
		Summary summarize(nsecs_t now);

		virtual void clear() = 0;
		virtual std::string dump() const = 0;
		};

		namespace impl {
		// Records per-layer history of scheduling-related information (primarily present time),
		// heuristically categorizes layers as active or inactive, and summarizes stats about
		// active layers (primarily maximum refresh rate). See go/content-fps-detection-in-scheduler.
		class LayerHistory : public android::scheduler::LayerHistory {
		public:
		LayerHistory();
		virtual ~LayerHistory();

		// Layers are unregistered when the weak reference expires.
		void registerLayer(Layer*, float lowRefreshRate, float highRefreshRate,
		LayerVoteType type) override;

		void setDisplayArea(uint32_t /displayArea/) override {}

		void setConfigChangePending(bool /pending/) override {}

		// Marks the layer as active, and records the given state to its history.
		void record(Layer*, nsecs_t presentTime, nsecs_t now, LayerUpdateType updateType) override;

		// Rebuilds sets of active/inactive layers, and accumulates stats for active layers.
		android::scheduler::LayerHistory::Summary summarize(nsecs_t now) override;

		void clear() override;
		std::string dump() const override;
		void clear();
		std::string dump() const;

		private:
		friend class android::scheduler::LayerHistoryTest;
		friend LayerHistoryTest;
		friend TestableScheduler;

		using LayerPair = std::pair<wp<Layer>, std::unique_ptr<LayerInfo>>;
		@@ -130,65 +101,6 @@ private:
		LayerInfos mLayerInfos GUARDED_BY(mLock);
		size_t mActiveLayersEnd GUARDED_BY(mLock) = 0;

		// Whether to emit systrace output and debug logs.
		const bool mTraceEnabled;

		// Whether to use priority sent from WindowManager to determine the relevancy of the layer.
		const bool mUseFrameRatePriority;
		};

		class LayerHistoryV2 : public android::scheduler::LayerHistory {
		public:
		LayerHistoryV2(const scheduler::RefreshRateConfigs&);
		virtual ~LayerHistoryV2();

		// Layers are unregistered when the weak reference expires.
		void registerLayer(Layer*, float lowRefreshRate, float highRefreshRate,
		LayerVoteType type) override;

		// Sets the display size. Client is responsible for synchronization.
		void setDisplayArea(uint32_t displayArea) override { mDisplayArea = displayArea; }

		void setConfigChangePending(bool pending) override { mConfigChangePending = pending; }

		// Marks the layer as active, and records the given state to its history.
		void record(Layer*, nsecs_t presentTime, nsecs_t now, LayerUpdateType updateType) override;

		// Rebuilds sets of active/inactive layers, and accumulates stats for active layers.
		android::scheduler::LayerHistory::Summary summarize(nsecs_t /now/) override;

		void clear() override;
		std::string dump() const override;

		private:
		friend android::scheduler::LayerHistoryTestV2;
		friend TestableScheduler;

		using LayerPair = std::pair<wp<Layer>, std::unique_ptr<LayerInfoV2>>;
		using LayerInfos = std::vector<LayerPair>;

		struct ActiveLayers {
		LayerInfos& infos;
		const size_t index;

		auto begin() { return infos.begin(); }
		auto end() { return begin() + static_cast<long>(index); }
		};

		ActiveLayers activeLayers() REQUIRES(mLock) { return {mLayerInfos, mActiveLayersEnd}; }

		// Iterates over layers in a single pass, swapping pairs such that active layers precede
		// inactive layers, and inactive layers precede expired layers. Removes expired layers by
		// truncating after inactive layers.
		void partitionLayers(nsecs_t now) REQUIRES(mLock);

		mutable std::mutex mLock;

		// Partitioned such that active layers precede inactive layers. For fast lookup, the few active
		// layers are at the front, and weak pointers are stored in contiguous memory to hit the cache.
		LayerInfos mLayerInfos GUARDED_BY(mLock);
		size_t mActiveLayersEnd GUARDED_BY(mLock) = 0;

		uint32_t mDisplayArea = 0;

		// Whether to emit systrace output and debug logs.
		@@ -201,6 +113,5 @@ private:
		std::atomic<bool> mConfigChangePending = false;
		};

		} // namespace impl
		} // namespace scheduler
		} // namespace android

services/surfaceflinger/Scheduler/LayerHistoryV2.cpp

deleted100644 → 0

+0 −224

Original line number	Diff line number	Diff line
		/*
		* Copyright 2020 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#undef LOG_TAG
		#define LOG_TAG "LayerHistoryV2"
		#define ATRACE_TAG ATRACE_TAG_GRAPHICS

		#include "LayerHistory.h"

		#include <android-base/stringprintf.h>
		#include <cutils/properties.h>
		#include <utils/Log.h>
		#include <utils/Timers.h>
		#include <utils/Trace.h>

		#include <algorithm>
		#include <cmath>
		#include <string>
		#include <utility>

		#include "../Layer.h"
		#include "LayerInfoV2.h"
		#include "SchedulerUtils.h"

		namespace android::scheduler::impl {

		namespace {

		bool isLayerActive(const Layer& layer, const LayerInfoV2& info, nsecs_t threshold) {
		// Layers with an explicit vote are always kept active
		if (layer.getFrameRateForLayerTree().rate > 0) {
		return true;
		}

		return layer.isVisible() && info.getLastUpdatedTime() >= threshold;
		}

		bool traceEnabled() {
		return property_get_bool("debug.sf.layer_history_trace", false);
		}

		bool useFrameRatePriority() {
		char value[PROPERTY_VALUE_MAX];
		property_get("debug.sf.use_frame_rate_priority", value, "1");
		return atoi(value);
		}

		void trace(const wp<Layer>& weak, const LayerInfoV2& info, LayerHistory::LayerVoteType type,
		int fps) {
		const auto layer = weak.promote();
		if (!layer) return;

		const auto traceType = [&](LayerHistory::LayerVoteType checkedType, int value) {
		ATRACE_INT(info.getTraceTag(checkedType), type == checkedType ? value : 0);
		};

		traceType(LayerHistory::LayerVoteType::NoVote, 1);
		traceType(LayerHistory::LayerVoteType::Heuristic, fps);
		traceType(LayerHistory::LayerVoteType::ExplicitDefault, fps);
		traceType(LayerHistory::LayerVoteType::ExplicitExactOrMultiple, fps);
		traceType(LayerHistory::LayerVoteType::Min, 1);
		traceType(LayerHistory::LayerVoteType::Max, 1);

		ALOGD("%s: %s @ %d Hz", __FUNCTION__, layer->getName().c_str(), fps);
		}
		} // namespace

		LayerHistoryV2::LayerHistoryV2(const scheduler::RefreshRateConfigs& refreshRateConfigs)
		: mTraceEnabled(traceEnabled()), mUseFrameRatePriority(useFrameRatePriority()) {
		LayerInfoV2::setTraceEnabled(mTraceEnabled);
		LayerInfoV2::setRefreshRateConfigs(refreshRateConfigs);
		}

		LayerHistoryV2::~LayerHistoryV2() = default;

		void LayerHistoryV2::registerLayer(Layer* layer, float /lowRefreshRate/, float highRefreshRate,
		LayerVoteType type) {
		const nsecs_t highRefreshRatePeriod = static_cast<nsecs_t>(1e9f / highRefreshRate);
		auto info = std::make_unique<LayerInfoV2>(layer->getName(), highRefreshRatePeriod, type);
		std::lock_guard lock(mLock);
		mLayerInfos.emplace_back(layer, std::move(info));
		}

		void LayerHistoryV2::record(Layer* layer, nsecs_t presentTime, nsecs_t now,
		LayerUpdateType updateType) {
		std::lock_guard lock(mLock);

		const auto it = std::find_if(mLayerInfos.begin(), mLayerInfos.end(),
		[layer](const auto& pair) { return pair.first == layer; });
		LOG_FATAL_IF(it == mLayerInfos.end(), "%s: unknown layer %p", __FUNCTION__, layer);

		const auto& info = it->second;
		info->setLastPresentTime(presentTime, now, updateType, mConfigChangePending);

		// Activate layer if inactive.
		if (const auto end = activeLayers().end(); it >= end) {
		std::iter_swap(it, end);
		mActiveLayersEnd++;
		}
		}

		LayerHistoryV2::Summary LayerHistoryV2::summarize(nsecs_t now) {
		LayerHistory::Summary summary;

		std::lock_guard lock(mLock);

		partitionLayers(now);

		for (const auto& [layer, info] : activeLayers()) {
		const auto strong = layer.promote();
		if (!strong) {
		continue;
		}

		const auto frameRateSelectionPriority = strong->getFrameRateSelectionPriority();
		const auto layerFocused = Layer::isLayerFocusedBasedOnPriority(frameRateSelectionPriority);
		ALOGV("%s has priority: %d %s focused", strong->getName().c_str(),
		frameRateSelectionPriority, layerFocused ? "" : "not");

		const auto vote = info->getRefreshRateVote(now);
		// Skip NoVote layer as those don't have any requirements
		if (vote.type == LayerHistory::LayerVoteType::NoVote) {
		continue;
		}

		// Compute the layer's position on the screen
		const Rect bounds = Rect(strong->getBounds());
		const ui::Transform transform = strong->getTransform();
		constexpr bool roundOutwards = true;
		Rect transformed = transform.transform(bounds, roundOutwards);

		const float layerArea = transformed.getWidth() * transformed.getHeight();
		float weight = mDisplayArea ? layerArea / mDisplayArea : 0.0f;
		summary.push_back(
		{strong->getName(), vote.type, vote.fps, vote.seamlessness, weight, layerFocused});

		if (CC_UNLIKELY(mTraceEnabled)) {
		trace(layer, *info, vote.type, static_cast<int>(std::round(vote.fps)));
		}
		}

		return summary;
		}

		void LayerHistoryV2::partitionLayers(nsecs_t now) {
		const nsecs_t threshold = getActiveLayerThreshold(now);

		// Collect expired and inactive layers after active layers.
		size_t i = 0;
		while (i < mActiveLayersEnd) {
		auto& [weak, info] = mLayerInfos[i];
		if (const auto layer = weak.promote(); layer && isLayerActive(layer, info, threshold)) {
		i++;
		// Set layer vote if set
		const auto frameRate = layer->getFrameRateForLayerTree();
		const auto voteType = [&]() {
		switch (frameRate.type) {
		case Layer::FrameRateCompatibility::Default:
		return LayerVoteType::ExplicitDefault;
		case Layer::FrameRateCompatibility::ExactOrMultiple:
		return LayerVoteType::ExplicitExactOrMultiple;
		case Layer::FrameRateCompatibility::NoVote:
		return LayerVoteType::NoVote;
		}
		}();

		if (frameRate.rate > 0 \|\| voteType == LayerVoteType::NoVote) {
		const auto type = layer->isVisible() ? voteType : LayerVoteType::NoVote;
		info->setLayerVote({type, frameRate.rate, frameRate.seamlessness});
		} else {
		info->resetLayerVote();
		}
		continue;
		}

		if (CC_UNLIKELY(mTraceEnabled)) {
		trace(weak, *info, LayerHistory::LayerVoteType::NoVote, 0);
		}

		info->onLayerInactive(now);
		std::swap(mLayerInfos[i], mLayerInfos[--mActiveLayersEnd]);
		}

		// Collect expired layers after inactive layers.
		size_t end = mLayerInfos.size();
		while (i < end) {
		if (mLayerInfos[i].first.promote()) {
		i++;
		} else {
		std::swap(mLayerInfos[i], mLayerInfos[--end]);
		}
		}

		mLayerInfos.erase(mLayerInfos.begin() + static_cast<long>(end), mLayerInfos.end());
		}

		void LayerHistoryV2::clear() {
		std::lock_guard lock(mLock);

		for (const auto& [layer, info] : activeLayers()) {
		info->clearHistory(systemTime());
		}
		}

		std::string LayerHistoryV2::dump() const {
		std::lock_guard lock(mLock);
		return base::StringPrintf("LayerHistoryV2{size=%zu, active=%zu}", mLayerInfos.size(),
		mActiveLayersEnd);
		}

		} // namespace android::scheduler::impl

services/surfaceflinger/Scheduler/LayerInfo.cpp

+264 −16

File changed.

Preview size limit exceeded, changes collapsed.