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 #undef LOG_TAG
18 #define LOG_TAG "LibSurfaceFlingerUnittests"
19
20 #include "DisplayHardware/DisplayMode.h"
21
22 #include "DisplayTransactionTestHelpers.h"
23
24 namespace android {
25 namespace {
26
27 using hal::RenderIntent;
28
29 // For this variant, SurfaceFlinger should configure itself with wide display
30 // support, and the display should respond with an non-empty list of supported
31 // color modes. Wide-color support should be configured.
32 template <typename Display>
33 struct WideColorP3ColorimetricSupportedVariant {
34 static constexpr bool WIDE_COLOR_SUPPORTED = true;
35
injectConfigChangeandroid::__anonb8f6e1c50110::WideColorP3ColorimetricSupportedVariant36 static void injectConfigChange(DisplayTransactionTest* test) {
37 test->mFlinger.mutableUseColorManagement() = true;
38 test->mFlinger.mutableHasWideColorDisplay() = true;
39 test->mFlinger.mutableDisplayColorSetting() = DisplayColorSetting::kUnmanaged;
40 }
41
setupComposerCallExpectationsandroid::__anonb8f6e1c50110::WideColorP3ColorimetricSupportedVariant42 static void setupComposerCallExpectations(DisplayTransactionTest* test) {
43 EXPECT_CALL(*test->mNativeWindow, perform(NATIVE_WINDOW_SET_BUFFERS_DATASPACE)).Times(1);
44
45 EXPECT_CALL(*test->mComposer, getColorModes(Display::HWC_DISPLAY_ID, _))
46 .WillOnce(DoAll(SetArgPointee<1>(std::vector<ColorMode>({ColorMode::DISPLAY_P3})),
47 Return(Error::NONE)));
48 EXPECT_CALL(*test->mComposer,
49 getRenderIntents(Display::HWC_DISPLAY_ID, ColorMode::DISPLAY_P3, _))
50 .WillOnce(DoAll(SetArgPointee<2>(
51 std::vector<RenderIntent>({RenderIntent::COLORIMETRIC})),
52 Return(Error::NONE)));
53 EXPECT_CALL(*test->mComposer,
54 setColorMode(Display::HWC_DISPLAY_ID, ColorMode::SRGB,
55 RenderIntent::COLORIMETRIC))
56 .WillOnce(Return(Error::NONE));
57 }
58 };
59
60 template <typename Display>
61 struct Hdr10PlusSupportedVariant {
62 static constexpr bool HDR10_PLUS_SUPPORTED = true;
63 static constexpr bool HDR10_SUPPORTED = true;
64 static constexpr bool HDR_HLG_SUPPORTED = false;
65 static constexpr bool HDR_DOLBY_VISION_SUPPORTED = false;
setupComposerCallExpectationsandroid::__anonb8f6e1c50110::Hdr10PlusSupportedVariant66 static void setupComposerCallExpectations(DisplayTransactionTest* test) {
67 EXPECT_CALL(*test->mComposer, getHdrCapabilities(_, _, _, _, _))
68 .WillOnce(DoAll(SetArgPointee<1>(std::vector<Hdr>({
69 Hdr::HDR10_PLUS,
70 Hdr::HDR10,
71 })),
72 Return(Error::NONE)));
73 }
74 };
75
76 // For this variant, the composer should respond with a non-empty list of HDR
77 // modes containing HDR10, so HDR10 support should be configured.
78 template <typename Display>
79 struct Hdr10SupportedVariant {
80 static constexpr bool HDR10_PLUS_SUPPORTED = false;
81 static constexpr bool HDR10_SUPPORTED = true;
82 static constexpr bool HDR_HLG_SUPPORTED = false;
83 static constexpr bool HDR_DOLBY_VISION_SUPPORTED = false;
setupComposerCallExpectationsandroid::__anonb8f6e1c50110::Hdr10SupportedVariant84 static void setupComposerCallExpectations(DisplayTransactionTest* test) {
85 EXPECT_CALL(*test->mComposer, getHdrCapabilities(Display::HWC_DISPLAY_ID, _, _, _, _))
86 .WillOnce(DoAll(SetArgPointee<1>(std::vector<Hdr>({Hdr::HDR10})),
87 Return(Error::NONE)));
88 }
89 };
90
91 // For this variant, the composer should respond with a non-empty list of HDR
92 // modes containing HLG, so HLG support should be configured.
93 template <typename Display>
94 struct HdrHlgSupportedVariant {
95 static constexpr bool HDR10_PLUS_SUPPORTED = false;
96 static constexpr bool HDR10_SUPPORTED = false;
97 static constexpr bool HDR_HLG_SUPPORTED = true;
98 static constexpr bool HDR_DOLBY_VISION_SUPPORTED = false;
setupComposerCallExpectationsandroid::__anonb8f6e1c50110::HdrHlgSupportedVariant99 static void setupComposerCallExpectations(DisplayTransactionTest* test) {
100 EXPECT_CALL(*test->mComposer, getHdrCapabilities(Display::HWC_DISPLAY_ID, _, _, _, _))
101 .WillOnce(
102 DoAll(SetArgPointee<1>(std::vector<Hdr>({Hdr::HLG})), Return(Error::NONE)));
103 }
104 };
105
106 // For this variant, the composer should respond with a non-empty list of HDR
107 // modes containing DOLBY_VISION, so DOLBY_VISION support should be configured.
108 template <typename Display>
109 struct HdrDolbyVisionSupportedVariant {
110 static constexpr bool HDR10_PLUS_SUPPORTED = false;
111 static constexpr bool HDR10_SUPPORTED = false;
112 static constexpr bool HDR_HLG_SUPPORTED = false;
113 static constexpr bool HDR_DOLBY_VISION_SUPPORTED = true;
setupComposerCallExpectationsandroid::__anonb8f6e1c50110::HdrDolbyVisionSupportedVariant114 static void setupComposerCallExpectations(DisplayTransactionTest* test) {
115 EXPECT_CALL(*test->mComposer, getHdrCapabilities(Display::HWC_DISPLAY_ID, _, _, _, _))
116 .WillOnce(DoAll(SetArgPointee<1>(std::vector<Hdr>({Hdr::DOLBY_VISION})),
117 Return(Error::NONE)));
118 }
119 };
120
121 template <typename Display>
122 struct Smpte2086PerFrameMetadataSupportVariant {
123 static constexpr int PER_FRAME_METADATA_KEYS = HdrMetadata::Type::SMPTE2086;
setupComposerCallExpectationsandroid::__anonb8f6e1c50110::Smpte2086PerFrameMetadataSupportVariant124 static void setupComposerCallExpectations(DisplayTransactionTest* test) {
125 EXPECT_CALL(*test->mComposer, getPerFrameMetadataKeys(Display::HWC_DISPLAY_ID))
126 .WillOnce(Return(std::vector<PerFrameMetadataKey>({
127 PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X,
128 PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y,
129 PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X,
130 PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y,
131 PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X,
132 PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y,
133 PerFrameMetadataKey::WHITE_POINT_X,
134 PerFrameMetadataKey::WHITE_POINT_Y,
135 PerFrameMetadataKey::MAX_LUMINANCE,
136 PerFrameMetadataKey::MIN_LUMINANCE,
137 })));
138 }
139 };
140
141 template <typename Display>
142 struct Cta861_3_PerFrameMetadataSupportVariant {
143 static constexpr int PER_FRAME_METADATA_KEYS = HdrMetadata::Type::CTA861_3;
setupComposerCallExpectationsandroid::__anonb8f6e1c50110::Cta861_3_PerFrameMetadataSupportVariant144 static void setupComposerCallExpectations(DisplayTransactionTest* test) {
145 EXPECT_CALL(*test->mComposer, getPerFrameMetadataKeys(Display::HWC_DISPLAY_ID))
146 .WillOnce(Return(std::vector<PerFrameMetadataKey>({
147 PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL,
148 PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL,
149 })));
150 }
151 };
152
153 template <typename Display>
154 struct Hdr10_Plus_PerFrameMetadataSupportVariant {
155 static constexpr int PER_FRAME_METADATA_KEYS = HdrMetadata::Type::HDR10PLUS;
setupComposerCallExpectationsandroid::__anonb8f6e1c50110::Hdr10_Plus_PerFrameMetadataSupportVariant156 static void setupComposerCallExpectations(DisplayTransactionTest* test) {
157 EXPECT_CALL(*test->mComposer, getPerFrameMetadataKeys(Display::HWC_DISPLAY_ID))
158 .WillOnce(Return(std::vector<PerFrameMetadataKey>({
159 PerFrameMetadataKey::HDR10_PLUS_SEI,
160 })));
161 }
162 };
163
164 using WideColorP3ColorimetricDisplayCase =
165 Case<PrimaryDisplayVariant, WideColorP3ColorimetricSupportedVariant<PrimaryDisplayVariant>,
166 HdrNotSupportedVariant<PrimaryDisplayVariant>,
167 NoPerFrameMetadataSupportVariant<PrimaryDisplayVariant>>;
168 using Hdr10PlusDisplayCase =
169 Case<PrimaryDisplayVariant, WideColorNotSupportedVariant<PrimaryDisplayVariant>,
170 Hdr10SupportedVariant<PrimaryDisplayVariant>,
171 Hdr10_Plus_PerFrameMetadataSupportVariant<PrimaryDisplayVariant>>;
172 using Hdr10DisplayCase =
173 Case<PrimaryDisplayVariant, WideColorNotSupportedVariant<PrimaryDisplayVariant>,
174 Hdr10SupportedVariant<PrimaryDisplayVariant>,
175 NoPerFrameMetadataSupportVariant<PrimaryDisplayVariant>>;
176 using HdrHlgDisplayCase =
177 Case<PrimaryDisplayVariant, WideColorNotSupportedVariant<PrimaryDisplayVariant>,
178 HdrHlgSupportedVariant<PrimaryDisplayVariant>,
179 NoPerFrameMetadataSupportVariant<PrimaryDisplayVariant>>;
180 using HdrDolbyVisionDisplayCase =
181 Case<PrimaryDisplayVariant, WideColorNotSupportedVariant<PrimaryDisplayVariant>,
182 HdrDolbyVisionSupportedVariant<PrimaryDisplayVariant>,
183 NoPerFrameMetadataSupportVariant<PrimaryDisplayVariant>>;
184 using HdrSmpte2086DisplayCase =
185 Case<PrimaryDisplayVariant, WideColorNotSupportedVariant<PrimaryDisplayVariant>,
186 HdrNotSupportedVariant<PrimaryDisplayVariant>,
187 Smpte2086PerFrameMetadataSupportVariant<PrimaryDisplayVariant>>;
188 using HdrCta861_3_DisplayCase =
189 Case<PrimaryDisplayVariant, WideColorNotSupportedVariant<PrimaryDisplayVariant>,
190 HdrNotSupportedVariant<PrimaryDisplayVariant>,
191 Cta861_3_PerFrameMetadataSupportVariant<PrimaryDisplayVariant>>;
192
193 class SetupNewDisplayDeviceInternalTest : public DisplayTransactionTest {
194 public:
195 template <typename T>
196 void setupNewDisplayDeviceInternalTest();
197 };
198
199 template <typename Case>
setupNewDisplayDeviceInternalTest()200 void SetupNewDisplayDeviceInternalTest::setupNewDisplayDeviceInternalTest() {
201 const sp<BBinder> displayToken = new BBinder();
202 const sp<compositionengine::mock::DisplaySurface> displaySurface =
203 new compositionengine::mock::DisplaySurface();
204 const sp<mock::GraphicBufferProducer> producer = new mock::GraphicBufferProducer();
205
206 // --------------------------------------------------------------------
207 // Preconditions
208
209 // Wide color displays support is configured appropriately
210 Case::WideColorSupport::injectConfigChange(this);
211
212 // The display is setup with the HWC.
213 Case::Display::injectHwcDisplay(this);
214
215 // SurfaceFlinger will use a test-controlled factory for native window
216 // surfaces.
217 injectFakeNativeWindowSurfaceFactory();
218
219 // A compositionengine::Display has already been created
220 auto compositionDisplay = Case::Display::injectCompositionDisplay(this);
221
222 // --------------------------------------------------------------------
223 // Call Expectations
224
225 // Various native window calls will be made.
226 Case::Display::setupNativeWindowSurfaceCreationCallExpectations(this);
227 Case::Display::setupHwcGetActiveConfigCallExpectations(this);
228 Case::Display::setupHwcGetConfigsCallExpectations(this);
229 Case::WideColorSupport::setupComposerCallExpectations(this);
230 Case::HdrSupport::setupComposerCallExpectations(this);
231 Case::PerFrameMetadataSupport::setupComposerCallExpectations(this);
232
233 // --------------------------------------------------------------------
234 // Invocation
235
236 DisplayDeviceState state;
237 if constexpr (constexpr auto connectionType = Case::Display::CONNECTION_TYPE::value) {
238 const auto displayId = PhysicalDisplayId::tryCast(Case::Display::DISPLAY_ID::get());
239 ASSERT_TRUE(displayId);
240 const auto hwcDisplayId = Case::Display::HWC_DISPLAY_ID_OPT::value;
241 ASSERT_TRUE(hwcDisplayId);
242 mFlinger.getHwComposer().allocatePhysicalDisplay(*hwcDisplayId, *displayId);
243 DisplayModePtr activeMode = DisplayMode::Builder(Case::Display::HWC_ACTIVE_CONFIG_ID)
244 .setWidth(Case::Display::WIDTH)
245 .setHeight(Case::Display::HEIGHT)
246 .setVsyncPeriod(DEFAULT_VSYNC_PERIOD)
247 .setDpiX(DEFAULT_DPI)
248 .setDpiY(DEFAULT_DPI)
249 .setGroup(0)
250 .build();
251 DisplayModes modes{activeMode};
252 state.physical = {.id = *displayId,
253 .type = *connectionType,
254 .hwcDisplayId = *hwcDisplayId,
255 .supportedModes = modes,
256 .activeMode = activeMode};
257 }
258
259 state.isSecure = static_cast<bool>(Case::Display::SECURE);
260
261 auto device = mFlinger.setupNewDisplayDeviceInternal(displayToken, compositionDisplay, state,
262 displaySurface, producer);
263
264 // --------------------------------------------------------------------
265 // Postconditions
266
267 ASSERT_TRUE(device != nullptr);
268 EXPECT_EQ(Case::Display::DISPLAY_ID::get(), device->getId());
269 EXPECT_EQ(Case::Display::CONNECTION_TYPE::value, device->getConnectionType());
270 EXPECT_EQ(static_cast<bool>(Case::Display::VIRTUAL), device->isVirtual());
271 EXPECT_EQ(static_cast<bool>(Case::Display::SECURE), device->isSecure());
272 EXPECT_EQ(static_cast<bool>(Case::Display::PRIMARY), device->isPrimary());
273 EXPECT_EQ(Case::Display::WIDTH, device->getWidth());
274 EXPECT_EQ(Case::Display::HEIGHT, device->getHeight());
275 EXPECT_EQ(Case::WideColorSupport::WIDE_COLOR_SUPPORTED, device->hasWideColorGamut());
276 EXPECT_EQ(Case::HdrSupport::HDR10_PLUS_SUPPORTED, device->hasHDR10PlusSupport());
277 EXPECT_EQ(Case::HdrSupport::HDR10_SUPPORTED, device->hasHDR10Support());
278 EXPECT_EQ(Case::HdrSupport::HDR_HLG_SUPPORTED, device->hasHLGSupport());
279 EXPECT_EQ(Case::HdrSupport::HDR_DOLBY_VISION_SUPPORTED, device->hasDolbyVisionSupport());
280 EXPECT_EQ(Case::PerFrameMetadataSupport::PER_FRAME_METADATA_KEYS,
281 device->getSupportedPerFrameMetadata());
282
283 if constexpr (Case::Display::CONNECTION_TYPE::value) {
284 EXPECT_EQ(1, device->getSupportedModes().size());
285 EXPECT_NE(nullptr, device->getActiveMode());
286 EXPECT_EQ(Case::Display::HWC_ACTIVE_CONFIG_ID, device->getActiveMode()->getHwcId());
287 }
288 }
289
TEST_F(SetupNewDisplayDeviceInternalTest,createSimplePrimaryDisplay)290 TEST_F(SetupNewDisplayDeviceInternalTest, createSimplePrimaryDisplay) {
291 setupNewDisplayDeviceInternalTest<SimplePrimaryDisplayCase>();
292 }
293
TEST_F(SetupNewDisplayDeviceInternalTest,createSimpleExternalDisplay)294 TEST_F(SetupNewDisplayDeviceInternalTest, createSimpleExternalDisplay) {
295 setupNewDisplayDeviceInternalTest<SimpleExternalDisplayCase>();
296 }
297
TEST_F(SetupNewDisplayDeviceInternalTest,createNonHwcVirtualDisplay)298 TEST_F(SetupNewDisplayDeviceInternalTest, createNonHwcVirtualDisplay) {
299 setupNewDisplayDeviceInternalTest<NonHwcVirtualDisplayCase>();
300 }
301
TEST_F(SetupNewDisplayDeviceInternalTest,createHwcVirtualDisplay)302 TEST_F(SetupNewDisplayDeviceInternalTest, createHwcVirtualDisplay) {
303 setupNewDisplayDeviceInternalTest<HwcVirtualDisplayCase>();
304 }
305
TEST_F(SetupNewDisplayDeviceInternalTest,createWideColorP3Display)306 TEST_F(SetupNewDisplayDeviceInternalTest, createWideColorP3Display) {
307 setupNewDisplayDeviceInternalTest<WideColorP3ColorimetricDisplayCase>();
308 }
309
TEST_F(SetupNewDisplayDeviceInternalTest,createHdr10PlusDisplay)310 TEST_F(SetupNewDisplayDeviceInternalTest, createHdr10PlusDisplay) {
311 setupNewDisplayDeviceInternalTest<Hdr10PlusDisplayCase>();
312 }
313
TEST_F(SetupNewDisplayDeviceInternalTest,createHdr10Display)314 TEST_F(SetupNewDisplayDeviceInternalTest, createHdr10Display) {
315 setupNewDisplayDeviceInternalTest<Hdr10DisplayCase>();
316 }
317
TEST_F(SetupNewDisplayDeviceInternalTest,createHdrHlgDisplay)318 TEST_F(SetupNewDisplayDeviceInternalTest, createHdrHlgDisplay) {
319 setupNewDisplayDeviceInternalTest<HdrHlgDisplayCase>();
320 }
321
TEST_F(SetupNewDisplayDeviceInternalTest,createHdrDolbyVisionDisplay)322 TEST_F(SetupNewDisplayDeviceInternalTest, createHdrDolbyVisionDisplay) {
323 setupNewDisplayDeviceInternalTest<HdrDolbyVisionDisplayCase>();
324 }
325
TEST_F(SetupNewDisplayDeviceInternalTest,createHdrSmpte2086DisplayCase)326 TEST_F(SetupNewDisplayDeviceInternalTest, createHdrSmpte2086DisplayCase) {
327 setupNewDisplayDeviceInternalTest<HdrSmpte2086DisplayCase>();
328 }
329
TEST_F(SetupNewDisplayDeviceInternalTest,createHdrCta816_3_DisplayCase)330 TEST_F(SetupNewDisplayDeviceInternalTest, createHdrCta816_3_DisplayCase) {
331 setupNewDisplayDeviceInternalTest<HdrCta861_3_DisplayCase>();
332 }
333
334 } // namespace
335 } // namespace android
336