SurfaceFlinger: use config groups
Composer 2.4 adds a new attribute for configs groups. This change
groups configs according to their group and store them in
RefreshRateConfigs.
Test: rev up composer to 2.4 and test refresh rate switching
Test: adb shell /data/nativetest64/libsurfaceflinger_unittest/libsurfaceflinger_unittest
Test: adb shell /data/nativetest64/SurfaceFlinger_test/SurfaceFlinger_test
Bug: 141329414
Fixes: 139751853
Change-Id: Ic0bcd3da4bf6b73efa11a60c2594948ce030362f
diff --git a/services/surfaceflinger/Scheduler/RefreshRateConfigs.h b/services/surfaceflinger/Scheduler/RefreshRateConfigs.h
index 90bba24..fb14dc7 100644
--- a/services/surfaceflinger/Scheduler/RefreshRateConfigs.h
+++ b/services/surfaceflinger/Scheduler/RefreshRateConfigs.h
@@ -23,7 +23,9 @@
#include <type_traits>
#include "DisplayHardware/HWComposer.h"
+#include "HwcStrongTypes.h"
#include "Scheduler/SchedulerUtils.h"
+#include "Scheduler/StrongTyping.h"
namespace android::scheduler {
@@ -41,71 +43,123 @@
*/
class RefreshRateConfigs {
public:
- // Enum to indicate which vsync rate to run at. Default is the old 60Hz, and performance
- // is the new 90Hz. Eventually we want to have a way for vendors to map these in the configs.
- enum class RefreshRateType { DEFAULT, PERFORMANCE };
-
struct RefreshRate {
+ RefreshRate(HwcConfigIndexType configId, nsecs_t vsyncPeriod,
+ HwcConfigGroupType configGroup, std::string name, float fps)
+ : configId(configId),
+ vsyncPeriod(vsyncPeriod),
+ configGroup(configGroup),
+ name(std::move(name)),
+ fps(fps) {}
// This config ID corresponds to the position of the config in the vector that is stored
// on the device.
- int configId;
- // Human readable name of the refresh rate.
- std::string name;
- // Refresh rate in frames per second, rounded to the nearest integer.
- uint32_t fps = 0;
+ const HwcConfigIndexType configId;
// Vsync period in nanoseconds.
- nsecs_t vsyncPeriod;
- // Hwc config Id (returned from HWC2::Display::Config::getId())
- hwc2_config_t hwcId;
+ const nsecs_t vsyncPeriod;
+ // This configGroup for the config.
+ const HwcConfigGroupType configGroup;
+ // Human readable name of the refresh rate.
+ const std::string name;
+ // Refresh rate in frames per second
+ const float fps = 0;
+
+ bool operator!=(const RefreshRate& other) const {
+ return configId != other.configId || vsyncPeriod != other.vsyncPeriod ||
+ configGroup != other.configGroup;
+ }
+
+ bool operator==(const RefreshRate& other) const { return !(*this != other); }
};
+ using AllRefreshRatesMapType = std::unordered_map<HwcConfigIndexType, const RefreshRate>;
+
+ // Sets the current policy to choose refresh rates.
+ void setPolicy(HwcConfigIndexType defaultConfigId, float minRefreshRate, float maxRefreshRate)
+ EXCLUDES(mLock);
+
// Returns true if this device is doing refresh rate switching. This won't change at runtime.
- bool refreshRateSwitchingSupported() const { return mRefreshRateSwitchingSupported; }
+ bool refreshRateSwitchingSupported() const { return mRefreshRateSwitching; }
- // Returns the refresh rate map. This map won't be modified at runtime, so it's safe to access
- // from multiple threads. This can only be called if refreshRateSwitching() returns true.
- // TODO(b/122916473): Get this information from configs prepared by vendors, instead of
- // baking them in.
- const std::map<RefreshRateType, RefreshRate>& getRefreshRateMap() const;
+ // Returns all available refresh rates according to the current policy.
+ const RefreshRate& getRefreshRateForContent(float contentFramerate) const EXCLUDES(mLock);
- const RefreshRate& getRefreshRateFromType(RefreshRateType type) const;
+ // Returns all the refresh rates supported by the device. This won't change at runtime.
+ const AllRefreshRatesMapType& getAllRefreshRates() const EXCLUDES(mLock);
- std::pair<RefreshRateType, const RefreshRate&> getCurrentRefreshRate() const;
+ // Returns the lowest refresh rate supported by the device. This won't change at runtime.
+ const RefreshRate& getMinRefreshRate() const { return *mMinSupportedRefreshRate; }
- const RefreshRate& getRefreshRateFromConfigId(int configId) const;
+ // Returns the lowest refresh rate according to the current policy. May change in runtime.
+ const RefreshRate& getMinRefreshRateByPolicy() const EXCLUDES(mLock);
- RefreshRateType getRefreshRateTypeFromHwcConfigId(hwc2_config_t hwcId) const;
+ // Returns the highest refresh rate supported by the device. This won't change at runtime.
+ const RefreshRate& getMaxRefreshRate() const { return *mMaxSupportedRefreshRate; }
- void setCurrentConfig(int config);
+ // Returns the highest refresh rate according to the current policy. May change in runtime.
+ const RefreshRate& getMaxRefreshRateByPolicy() const EXCLUDES(mLock);
+
+ // Returns the current refresh rate
+ const RefreshRate& getCurrentRefreshRate() const EXCLUDES(mLock);
+
+ // Returns the refresh rate that corresponds to a HwcConfigIndexType. This won't change at
+ // runtime.
+ const RefreshRate& getRefreshRateFromConfigId(HwcConfigIndexType configId) const {
+ return mRefreshRates.at(configId);
+ };
+
+ // Stores the current configId the device operates at
+ void setCurrentConfigId(HwcConfigIndexType configId) EXCLUDES(mLock);
struct InputConfig {
- hwc2_config_t hwcId = 0;
+ HwcConfigIndexType configId = HwcConfigIndexType(0);
+ HwcConfigGroupType configGroup = HwcConfigGroupType(0);
nsecs_t vsyncPeriod = 0;
};
RefreshRateConfigs(bool refreshRateSwitching, const std::vector<InputConfig>& configs,
- int currentConfig);
-
+ HwcConfigIndexType currentHwcConfig);
RefreshRateConfigs(bool refreshRateSwitching,
const std::vector<std::shared_ptr<const HWC2::Display::Config>>& configs,
- int currentConfig);
+ HwcConfigIndexType currentConfigId);
private:
- void init(bool refreshRateSwitching, const std::vector<InputConfig>& configs,
- int currentConfig);
- // Whether this device is doing refresh rate switching or not. This must not change after this
- // object is initialized.
- bool mRefreshRateSwitchingSupported;
+ void init(const std::vector<InputConfig>& configs, HwcConfigIndexType currentHwcConfig);
+
+ void constructAvailableRefreshRates() REQUIRES(mLock);
+
+ void getSortedRefreshRateList(
+ const std::function<bool(const RefreshRate&)>& shouldAddRefreshRate,
+ std::vector<const RefreshRate*>* outRefreshRates);
+
// The list of refresh rates, indexed by display config ID. This must not change after this
// object is initialized.
- std::vector<RefreshRate> mRefreshRates;
- // The mapping of refresh rate type to RefreshRate. This must not change after this object is
- // initialized.
- std::map<RefreshRateType, RefreshRate> mRefreshRateMap;
- // The ID of the current config. This will change at runtime. This is set by SurfaceFlinger on
- // the main thread, and read by the Scheduler (and other objects) on other threads, so it's
- // atomic.
- std::atomic<int> mCurrentConfig;
+ AllRefreshRatesMapType mRefreshRates;
+
+ // The list of refresh rates which are available in the current policy, ordered by vsyncPeriod
+ // (the first element is the lowest refresh rate)
+ std::vector<const RefreshRate*> mAvailableRefreshRates GUARDED_BY(mLock);
+
+ // The current config. This will change at runtime. This is set by SurfaceFlinger on
+ // the main thread, and read by the Scheduler (and other objects) on other threads.
+ const RefreshRate* mCurrentRefreshRate GUARDED_BY(mLock);
+
+ // The current config group. This will change at runtime. This is set by SurfaceFlinger on
+ // the main thread, and read by the Scheduler (and other objects) on other threads.
+ HwcConfigGroupType mCurrentGroupId GUARDED_BY(mLock);
+
+ // The min and max FPS allowed by the policy. This will change at runtime and set by
+ // SurfaceFlinger on the main thread.
+ float mMinRefreshRateFps GUARDED_BY(mLock) = 0;
+ float mMaxRefreshRateFps GUARDED_BY(mLock) = std::numeric_limits<float>::max();
+
+ // The min and max refresh rates supported by the device.
+ // This will not change at runtime.
+ const RefreshRate* mMinSupportedRefreshRate;
+ const RefreshRate* mMaxSupportedRefreshRate;
+
+ const bool mRefreshRateSwitching;
+
+ mutable std::mutex mLock;
};
} // namespace android::scheduler