blob: 60328e48a69a6152dd306b2745083da26dc0b9fc [file] [log] [blame]
Alec Mouri671d0f52019-09-05 13:59:19 -07001/*
2 * Copyright 2019 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#include <apex/display.h>
18#include <gui/SurfaceComposerClient.h>
Marin Shalamanova7fe3042021-01-29 21:02:08 +010019#include <ui/DisplayMode.h>
Marin Shalamanov228f46b2021-01-28 21:11:45 +010020#include <ui/DynamicDisplayInfo.h>
Alec Mouri671d0f52019-09-05 13:59:19 -070021#include <ui/GraphicTypes.h>
Alec Mouri46170512019-11-20 11:04:55 -080022#include <ui/PixelFormat.h>
Marin Shalamanov228f46b2021-01-28 21:11:45 +010023#include <ui/StaticDisplayInfo.h>
Alec Mouri671d0f52019-09-05 13:59:19 -070024
25#include <algorithm>
26#include <optional>
27#include <type_traits>
28#include <vector>
29
30namespace android::display::impl {
31
32/**
33 * Implementation of ADisplayConfig
34 */
35struct DisplayConfigImpl {
36 /**
Marin Shalamanov228f46b2021-01-28 21:11:45 +010037 * The ID of the display configuration.
38 */
39 size_t id;
40
41 /**
Alec Mouri671d0f52019-09-05 13:59:19 -070042 * The width in pixels of the display configuration.
43 */
44 int32_t width{0};
45
46 /**
47 * The height in pixels of the display configuration.
48 */
49
50 int32_t height{0};
51
52 /**
Alec Mouri671d0f52019-09-05 13:59:19 -070053 * The refresh rate of the display configuration, in frames per second.
54 */
55 float fps{0.0};
56
57 /**
58 * The vsync offset at which surfaceflinger runs, in nanoseconds.
59 */
60 int64_t sfOffset{0};
61
62 /**
63 * The vsync offset at which applications run, in nanoseconds.
64 */
65 int64_t appOffset{0};
66};
67
68// DisplayConfigImpl allocation is not managed through C++ memory apis, so
69// preventing calling the destructor here.
70static_assert(std::is_trivially_destructible<DisplayConfigImpl>::value);
71
72/**
73 * Implementation of ADisplay
74 */
75struct DisplayImpl {
76 /**
77 * A physical display ID, unique to this display.
78 */
79 PhysicalDisplayId id;
80
81 /**
82 * The type of the display, i.e. whether it is an internal or external
83 * display.
84 */
85 ADisplayType type;
86
87 /**
Alec Mouri46170512019-11-20 11:04:55 -080088 * The preferred WCG dataspace
89 */
90 ADataSpace wcgDataspace;
91
92 /**
93 * The preferred WCG pixel format
94 */
95 AHardwareBuffer_Format wcgPixelFormat;
96
97 /**
Alec Mouri671d0f52019-09-05 13:59:19 -070098 * Number of supported configs
99 */
100 size_t numConfigs;
101
102 /**
103 * Set of supported configs by this display.
104 */
105 DisplayConfigImpl* configs;
106};
107
108// DisplayImpl allocation is not managed through C++ memory apis, so
109// preventing calling the destructor here.
110static_assert(std::is_trivially_destructible<DisplayImpl>::value);
111
112} // namespace android::display::impl
113
114using namespace android;
115using namespace android::display::impl;
116
117#define CHECK_NOT_NULL(name) \
118 LOG_ALWAYS_FATAL_IF(name == nullptr, "nullptr passed as " #name " argument");
119
120namespace {
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800121
Alec Mouri671d0f52019-09-05 13:59:19 -0700122sp<IBinder> getToken(ADisplay* display) {
123 DisplayImpl* impl = reinterpret_cast<DisplayImpl*>(display);
124 return SurfaceComposerClient::getPhysicalDisplayToken(impl->id);
125}
126
Alec Mouri671d0f52019-09-05 13:59:19 -0700127} // namespace
128
Alec Mourid9ff3272019-11-19 16:23:59 -0800129namespace android {
130
Alec Mouri671d0f52019-09-05 13:59:19 -0700131int ADisplay_acquirePhysicalDisplays(ADisplay*** outDisplays) {
132 const std::vector<PhysicalDisplayId> ids = SurfaceComposerClient::getPhysicalDisplayIds();
133 const size_t size = ids.size();
134 if (size == 0) {
135 return NO_INIT;
136 }
137
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100138 std::vector<DisplayConfigImpl> modesPerDisplay[size];
Huihong Luo31b5ac22022-08-15 20:38:10 -0700139 ui::DisplayConnectionType displayConnectionTypes[size];
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100140 int numModes = 0;
Alec Mouri671d0f52019-09-05 13:59:19 -0700141 for (int i = 0; i < size; ++i) {
142 const sp<IBinder> token = SurfaceComposerClient::getPhysicalDisplayToken(ids[i]);
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800143
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100144 ui::StaticDisplayInfo staticInfo;
145 if (const status_t status = SurfaceComposerClient::getStaticDisplayInfo(token, &staticInfo);
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800146 status != OK) {
147 return status;
148 }
Huihong Luo31b5ac22022-08-15 20:38:10 -0700149 displayConnectionTypes[i] = staticInfo.connectionType;
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800150
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100151 ui::DynamicDisplayInfo dynamicInfo;
152 if (const status_t status =
153 SurfaceComposerClient::getDynamicDisplayInfo(token, &dynamicInfo);
Dominik Laskowski3cb3d4e2019-11-21 11:14:45 -0800154 status != OK) {
Alec Mouri671d0f52019-09-05 13:59:19 -0700155 return status;
156 }
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100157 const auto& modes = dynamicInfo.supportedDisplayModes;
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100158 if (modes.empty()) {
Alec Mouri671d0f52019-09-05 13:59:19 -0700159 return NO_INIT;
160 }
161
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100162 numModes += modes.size();
163 modesPerDisplay[i].reserve(modes.size());
164 for (int j = 0; j < modes.size(); ++j) {
165 const ui::DisplayMode& mode = modes[j];
166 modesPerDisplay[i].emplace_back(
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100167 DisplayConfigImpl{static_cast<size_t>(mode.id), mode.resolution.getWidth(),
Brian Lindahl9b416b02022-01-12 10:57:39 +0100168 mode.resolution.getHeight(), mode.refreshRate,
169 mode.sfVsyncOffset, mode.appVsyncOffset});
Alec Mouri671d0f52019-09-05 13:59:19 -0700170 }
171 }
172
Alec Mouri46170512019-11-20 11:04:55 -0800173 ui::Dataspace defaultDataspace;
174 ui::PixelFormat defaultPixelFormat;
175 ui::Dataspace wcgDataspace;
176 ui::PixelFormat wcgPixelFormat;
177
178 const status_t status =
179 SurfaceComposerClient::getCompositionPreference(&defaultDataspace, &defaultPixelFormat,
180 &wcgDataspace, &wcgPixelFormat);
181 if (status != NO_ERROR) {
182 return status;
183 }
Alec Mouri671d0f52019-09-05 13:59:19 -0700184
185 // Here we allocate all our required memory in one block. The layout is as
186 // follows:
187 // ------------------------------------------------------------
188 // | DisplayImpl pointers | DisplayImpls | DisplayConfigImpls |
189 // ------------------------------------------------------------
190 //
191 // The caller will be given a DisplayImpl** which points to the beginning of
192 // the block of DisplayImpl pointers.
193 // Each DisplayImpl* points to a DisplayImpl in the second block.
194 // Each DisplayImpl contains a DisplayConfigImpl*, which points to a
195 // contiguous block of DisplayConfigImpls specific to that display.
196 DisplayImpl** const impls = reinterpret_cast<DisplayImpl**>(
197 malloc((sizeof(DisplayImpl) + sizeof(DisplayImpl*)) * size +
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100198 sizeof(DisplayConfigImpl) * numModes));
Alec Mouri671d0f52019-09-05 13:59:19 -0700199 DisplayImpl* const displayData = reinterpret_cast<DisplayImpl*>(impls + size);
200 DisplayConfigImpl* configData = reinterpret_cast<DisplayConfigImpl*>(displayData + size);
201
202 for (size_t i = 0; i < size; ++i) {
203 const PhysicalDisplayId id = ids[i];
Huihong Luo31b5ac22022-08-15 20:38:10 -0700204 const ADisplayType type = (displayConnectionTypes[i] == ui::DisplayConnectionType::Internal)
205 ? ADisplayType::DISPLAY_TYPE_INTERNAL
206 : ADisplayType::DISPLAY_TYPE_EXTERNAL;
Marin Shalamanova7fe3042021-01-29 21:02:08 +0100207 const std::vector<DisplayConfigImpl>& configs = modesPerDisplay[i];
Alec Mouri671d0f52019-09-05 13:59:19 -0700208 memcpy(configData, configs.data(), sizeof(DisplayConfigImpl) * configs.size());
209
Alec Mouri46170512019-11-20 11:04:55 -0800210 displayData[i] = DisplayImpl{id,
211 type,
212 static_cast<ADataSpace>(wcgDataspace),
213 static_cast<AHardwareBuffer_Format>(wcgPixelFormat),
214 configs.size(),
215 configData};
Alec Mouri671d0f52019-09-05 13:59:19 -0700216 impls[i] = displayData + i;
217 // Advance the configData pointer so that future configs are written to
218 // the correct display.
219 configData += configs.size();
220 }
221
222 *outDisplays = reinterpret_cast<ADisplay**>(impls);
223 return size;
224}
225
226void ADisplay_release(ADisplay** displays) {
227 if (displays == nullptr) {
228 return;
229 }
230 free(displays);
231}
232
233float ADisplay_getMaxSupportedFps(ADisplay* display) {
234 CHECK_NOT_NULL(display);
235 DisplayImpl* impl = reinterpret_cast<DisplayImpl*>(display);
236 float maxFps = 0.0;
237 for (int i = 0; i < impl->numConfigs; ++i) {
238 maxFps = std::max(maxFps, impl->configs[i].fps);
239 }
240 return maxFps;
241}
242
243ADisplayType ADisplay_getDisplayType(ADisplay* display) {
244 CHECK_NOT_NULL(display);
245
246 return reinterpret_cast<DisplayImpl*>(display)->type;
247}
248
Alec Mouri46170512019-11-20 11:04:55 -0800249void ADisplay_getPreferredWideColorFormat(ADisplay* display, ADataSpace* outDataspace,
250 AHardwareBuffer_Format* outPixelFormat) {
251 CHECK_NOT_NULL(display);
252 CHECK_NOT_NULL(outDataspace);
253 CHECK_NOT_NULL(outPixelFormat);
254
255 DisplayImpl* impl = reinterpret_cast<DisplayImpl*>(display);
256 *outDataspace = impl->wcgDataspace;
257 *outPixelFormat = impl->wcgPixelFormat;
258}
259
Alec Mouri671d0f52019-09-05 13:59:19 -0700260int ADisplay_getCurrentConfig(ADisplay* display, ADisplayConfig** outConfig) {
261 CHECK_NOT_NULL(display);
262
263 sp<IBinder> token = getToken(display);
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100264 ui::DynamicDisplayInfo info;
265 if (const auto status = SurfaceComposerClient::getDynamicDisplayInfo(token, &info);
266 status != OK) {
267 return status;
Alec Mouri671d0f52019-09-05 13:59:19 -0700268 }
269
270 DisplayImpl* impl = reinterpret_cast<DisplayImpl*>(display);
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100271 for (size_t i = 0; i < impl->numConfigs; i++) {
272 auto* config = impl->configs + i;
273 if (config->id == info.activeDisplayModeId) {
274 *outConfig = reinterpret_cast<ADisplayConfig*>(config);
275 return OK;
276 }
277 }
Alec Mouri671d0f52019-09-05 13:59:19 -0700278
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100279 return NAME_NOT_FOUND;
Alec Mouri671d0f52019-09-05 13:59:19 -0700280}
281
Alec Mouri671d0f52019-09-05 13:59:19 -0700282int32_t ADisplayConfig_getWidth(ADisplayConfig* config) {
283 CHECK_NOT_NULL(config);
284
285 return reinterpret_cast<DisplayConfigImpl*>(config)->width;
286}
287
288int32_t ADisplayConfig_getHeight(ADisplayConfig* config) {
289 CHECK_NOT_NULL(config);
290
291 return reinterpret_cast<DisplayConfigImpl*>(config)->height;
292}
293
294float ADisplayConfig_getFps(ADisplayConfig* config) {
295 CHECK_NOT_NULL(config);
296
297 return reinterpret_cast<DisplayConfigImpl*>(config)->fps;
298}
299
300int64_t ADisplayConfig_getCompositorOffsetNanos(ADisplayConfig* config) {
301 CHECK_NOT_NULL(config);
302
303 return reinterpret_cast<DisplayConfigImpl*>(config)->sfOffset;
304}
305
306int64_t ADisplayConfig_getAppVsyncOffsetNanos(ADisplayConfig* config) {
307 CHECK_NOT_NULL(config);
308
309 return reinterpret_cast<DisplayConfigImpl*>(config)->appOffset;
310}
Alec Mourid9ff3272019-11-19 16:23:59 -0800311
312} // namespace android