Marin Shalamanov | 3ea1d60 | 2020-12-16 19:59:39 +0100 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2020 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #pragma once |
| 18 | |
| 19 | #include "DisplayHardware/Hal.h" |
Marin Shalamanov | 5801c94 | 2020-12-17 17:00:13 +0100 | [diff] [blame] | 20 | #include "Fps.h" |
Marin Shalamanov | 23c4420 | 2020-12-22 19:09:20 +0100 | [diff] [blame] | 21 | #include "Scheduler/StrongTyping.h" |
Marin Shalamanov | 3ea1d60 | 2020-12-16 19:59:39 +0100 | [diff] [blame] | 22 | |
Marin Shalamanov | 5801c94 | 2020-12-17 17:00:13 +0100 | [diff] [blame] | 23 | #include <android-base/stringprintf.h> |
Marin Shalamanov | 3ea1d60 | 2020-12-16 19:59:39 +0100 | [diff] [blame] | 24 | #include <android/configuration.h> |
Ady Abraham | 5e7ee86 | 2021-06-23 17:43:41 -0700 | [diff] [blame^] | 25 | #include <ui/DisplayId.h> |
Marin Shalamanov | 228f46b | 2021-01-28 21:11:45 +0100 | [diff] [blame] | 26 | #include <ui/DisplayMode.h> |
Marin Shalamanov | 045b700 | 2021-01-07 16:56:24 +0100 | [diff] [blame] | 27 | #include <ui/Size.h> |
Marin Shalamanov | 3ea1d60 | 2020-12-16 19:59:39 +0100 | [diff] [blame] | 28 | #include <utils/Timers.h> |
| 29 | |
Marin Shalamanov | 23c4420 | 2020-12-22 19:09:20 +0100 | [diff] [blame] | 30 | #include <cstddef> |
Marin Shalamanov | 3ea1d60 | 2020-12-16 19:59:39 +0100 | [diff] [blame] | 31 | #include <memory> |
| 32 | #include <vector> |
| 33 | |
| 34 | namespace android { |
| 35 | |
| 36 | namespace hal = android::hardware::graphics::composer::hal; |
| 37 | |
| 38 | class DisplayMode; |
| 39 | using DisplayModePtr = std::shared_ptr<const DisplayMode>; |
| 40 | using DisplayModes = std::vector<DisplayModePtr>; |
Marin Shalamanov | 228f46b | 2021-01-28 21:11:45 +0100 | [diff] [blame] | 41 | using DisplayModeId = StrongTyping<ui::DisplayModeId, struct DisplayModeIdTag, Compare, Hash>; |
Marin Shalamanov | 3ea1d60 | 2020-12-16 19:59:39 +0100 | [diff] [blame] | 42 | |
| 43 | class DisplayMode { |
| 44 | public: |
| 45 | class Builder { |
| 46 | public: |
| 47 | explicit Builder(hal::HWConfigId id) : mDisplayMode(new DisplayMode(id)) {} |
| 48 | |
| 49 | DisplayModePtr build() { |
| 50 | return std::const_pointer_cast<const DisplayMode>(std::move(mDisplayMode)); |
| 51 | } |
| 52 | |
Marin Shalamanov | 23c4420 | 2020-12-22 19:09:20 +0100 | [diff] [blame] | 53 | Builder& setId(DisplayModeId id) { |
Marin Shalamanov | 3ea1d60 | 2020-12-16 19:59:39 +0100 | [diff] [blame] | 54 | mDisplayMode->mId = id; |
| 55 | return *this; |
| 56 | } |
| 57 | |
Ady Abraham | 5e7ee86 | 2021-06-23 17:43:41 -0700 | [diff] [blame^] | 58 | Builder& setPhysicalDisplayId(PhysicalDisplayId id) { |
| 59 | mDisplayMode->mPhysicalDisplayId = id; |
| 60 | return *this; |
| 61 | } |
| 62 | |
Marin Shalamanov | 3ea1d60 | 2020-12-16 19:59:39 +0100 | [diff] [blame] | 63 | Builder& setWidth(int32_t width) { |
| 64 | mDisplayMode->mWidth = width; |
| 65 | return *this; |
| 66 | } |
| 67 | |
| 68 | Builder& setHeight(int32_t height) { |
| 69 | mDisplayMode->mHeight = height; |
| 70 | return *this; |
| 71 | } |
| 72 | |
| 73 | Builder& setVsyncPeriod(int32_t vsyncPeriod) { |
Marin Shalamanov | 5801c94 | 2020-12-17 17:00:13 +0100 | [diff] [blame] | 74 | mDisplayMode->mFps = Fps::fromPeriodNsecs(vsyncPeriod); |
Marin Shalamanov | 3ea1d60 | 2020-12-16 19:59:39 +0100 | [diff] [blame] | 75 | return *this; |
| 76 | } |
| 77 | |
| 78 | Builder& setDpiX(int32_t dpiX) { |
| 79 | if (dpiX == -1) { |
| 80 | mDisplayMode->mDpiX = getDefaultDensity(); |
| 81 | } else { |
| 82 | mDisplayMode->mDpiX = dpiX / 1000.0f; |
| 83 | } |
| 84 | return *this; |
| 85 | } |
| 86 | |
| 87 | Builder& setDpiY(int32_t dpiY) { |
| 88 | if (dpiY == -1) { |
| 89 | mDisplayMode->mDpiY = getDefaultDensity(); |
| 90 | } else { |
| 91 | mDisplayMode->mDpiY = dpiY / 1000.0f; |
| 92 | } |
| 93 | return *this; |
| 94 | } |
| 95 | |
Marin Shalamanov | a7fe304 | 2021-01-29 21:02:08 +0100 | [diff] [blame] | 96 | Builder& setGroup(int32_t group) { |
| 97 | mDisplayMode->mGroup = group; |
Marin Shalamanov | 3ea1d60 | 2020-12-16 19:59:39 +0100 | [diff] [blame] | 98 | return *this; |
| 99 | } |
| 100 | |
| 101 | private: |
| 102 | float getDefaultDensity() { |
| 103 | // Default density is based on TVs: 1080p displays get XHIGH density, lower- |
| 104 | // resolution displays get TV density. Maybe eventually we'll need to update |
| 105 | // it for 4k displays, though hopefully those will just report accurate DPI |
| 106 | // information to begin with. This is also used for virtual displays and |
| 107 | // older HWC implementations, so be careful about orientation. |
| 108 | |
| 109 | auto longDimension = std::max(mDisplayMode->mWidth, mDisplayMode->mHeight); |
| 110 | if (longDimension >= 1080) { |
| 111 | return ACONFIGURATION_DENSITY_XHIGH; |
| 112 | } else { |
| 113 | return ACONFIGURATION_DENSITY_TV; |
| 114 | } |
| 115 | } |
| 116 | std::shared_ptr<DisplayMode> mDisplayMode; |
| 117 | }; |
| 118 | |
Marin Shalamanov | 23c4420 | 2020-12-22 19:09:20 +0100 | [diff] [blame] | 119 | DisplayModeId getId() const { return mId; } |
Marin Shalamanov | 3ea1d60 | 2020-12-16 19:59:39 +0100 | [diff] [blame] | 120 | hal::HWConfigId getHwcId() const { return mHwcId; } |
Ady Abraham | 5e7ee86 | 2021-06-23 17:43:41 -0700 | [diff] [blame^] | 121 | PhysicalDisplayId getPhysicalDisplayId() const { return mPhysicalDisplayId; } |
Marin Shalamanov | 3ea1d60 | 2020-12-16 19:59:39 +0100 | [diff] [blame] | 122 | |
| 123 | int32_t getWidth() const { return mWidth; } |
| 124 | int32_t getHeight() const { return mHeight; } |
Marin Shalamanov | 045b700 | 2021-01-07 16:56:24 +0100 | [diff] [blame] | 125 | ui::Size getSize() const { return {mWidth, mHeight}; } |
Marin Shalamanov | 5801c94 | 2020-12-17 17:00:13 +0100 | [diff] [blame] | 126 | Fps getFps() const { return mFps; } |
| 127 | nsecs_t getVsyncPeriod() const { return mFps.getPeriodNsecs(); } |
Marin Shalamanov | 3ea1d60 | 2020-12-16 19:59:39 +0100 | [diff] [blame] | 128 | float getDpiX() const { return mDpiX; } |
| 129 | float getDpiY() const { return mDpiY; } |
Marin Shalamanov | a7fe304 | 2021-01-29 21:02:08 +0100 | [diff] [blame] | 130 | |
| 131 | // Switches between modes in the same group are seamless, i.e. |
| 132 | // without visual interruptions such as a black screen. |
| 133 | int32_t getGroup() const { return mGroup; } |
Marin Shalamanov | 3ea1d60 | 2020-12-16 19:59:39 +0100 | [diff] [blame] | 134 | |
Marin Shalamanov | f22e6ac | 2021-02-10 20:45:15 +0100 | [diff] [blame] | 135 | bool equalsExceptDisplayModeId(const DisplayModePtr& other) const { |
| 136 | return mHwcId == other->mHwcId && mWidth == other->mWidth && mHeight == other->mHeight && |
| 137 | getVsyncPeriod() == other->getVsyncPeriod() && mDpiX == other->mDpiX && |
| 138 | mDpiY == other->mDpiY && mGroup == other->mGroup; |
| 139 | } |
| 140 | |
Marin Shalamanov | 3ea1d60 | 2020-12-16 19:59:39 +0100 | [diff] [blame] | 141 | private: |
| 142 | explicit DisplayMode(hal::HWConfigId id) : mHwcId(id) {} |
| 143 | |
| 144 | hal::HWConfigId mHwcId; |
Marin Shalamanov | 23c4420 | 2020-12-22 19:09:20 +0100 | [diff] [blame] | 145 | DisplayModeId mId; |
Ady Abraham | 5e7ee86 | 2021-06-23 17:43:41 -0700 | [diff] [blame^] | 146 | PhysicalDisplayId mPhysicalDisplayId; |
Marin Shalamanov | 3ea1d60 | 2020-12-16 19:59:39 +0100 | [diff] [blame] | 147 | |
| 148 | int32_t mWidth = -1; |
| 149 | int32_t mHeight = -1; |
Marin Shalamanov | 5801c94 | 2020-12-17 17:00:13 +0100 | [diff] [blame] | 150 | Fps mFps; |
Marin Shalamanov | 3ea1d60 | 2020-12-16 19:59:39 +0100 | [diff] [blame] | 151 | float mDpiX = -1; |
| 152 | float mDpiY = -1; |
Marin Shalamanov | a7fe304 | 2021-01-29 21:02:08 +0100 | [diff] [blame] | 153 | int32_t mGroup = -1; |
Marin Shalamanov | 3ea1d60 | 2020-12-16 19:59:39 +0100 | [diff] [blame] | 154 | }; |
| 155 | |
Marin Shalamanov | 5801c94 | 2020-12-17 17:00:13 +0100 | [diff] [blame] | 156 | inline std::string to_string(const DisplayMode& mode) { |
Marin Shalamanov | 228f46b | 2021-01-28 21:11:45 +0100 | [diff] [blame] | 157 | return base::StringPrintf("{id=%d, hwcId=%d, width=%d, height=%d, refreshRate=%s, " |
Marin Shalamanov | a7fe304 | 2021-01-29 21:02:08 +0100 | [diff] [blame] | 158 | "dpiX=%.2f, dpiY=%.2f, group=%d}", |
Marin Shalamanov | 5801c94 | 2020-12-17 17:00:13 +0100 | [diff] [blame] | 159 | mode.getId().value(), mode.getHwcId(), mode.getWidth(), |
| 160 | mode.getHeight(), to_string(mode.getFps()).c_str(), mode.getDpiX(), |
Marin Shalamanov | a7fe304 | 2021-01-29 21:02:08 +0100 | [diff] [blame] | 161 | mode.getDpiY(), mode.getGroup()); |
Marin Shalamanov | 5801c94 | 2020-12-17 17:00:13 +0100 | [diff] [blame] | 162 | } |
| 163 | |
Marin Shalamanov | 3ea1d60 | 2020-12-16 19:59:39 +0100 | [diff] [blame] | 164 | } // namespace android |