1 /**
2 * Copyright (c) 2021, 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 #define LOG_TAG "graphics_composer_aidl_hal_readback_tests@3"
18
19 #include <aidl/Gtest.h>
20 #include <aidl/Vintf.h>
21 #include <aidl/android/hardware/graphics/common/BufferUsage.h>
22 #include <aidl/android/hardware/graphics/composer3/IComposer.h>
23 #include <gtest/gtest.h>
24 #include <ui/DisplayId.h>
25 #include <ui/DisplayIdentification.h>
26 #include <ui/GraphicBuffer.h>
27 #include <ui/PixelFormat.h>
28 #include <ui/Rect.h>
29 #include "GraphicsComposerCallback.h"
30 #include "ReadbackVts.h"
31 #include "RenderEngineVts.h"
32 #include "VtsComposerClient.h"
33
34 namespace aidl::android::hardware::graphics::composer3::vts {
35 namespace {
36
37 using ::android::Rect;
38 using common::Dataspace;
39 using common::PixelFormat;
40
41 class GraphicsCompositionTestBase : public ::testing::Test {
42 protected:
SetUpBase(const std::string & name)43 void SetUpBase(const std::string& name) {
44 mComposerClient = std::make_shared<VtsComposerClient>(name);
45 ASSERT_TRUE(mComposerClient->createClient().isOk());
46
47 const auto& [status, displays] = mComposerClient->getDisplays();
48 ASSERT_TRUE(status.isOk());
49 mDisplays = displays;
50 mWriter.reset(new ComposerClientWriter(getPrimaryDisplayId()));
51
52 setTestColorModes();
53
54 // explicitly disable vsync
55 for (const auto& display : mDisplays) {
56 EXPECT_TRUE(mComposerClient->setVsync(display.getDisplayId(), /*enable*/ false).isOk());
57 }
58 mComposerClient->setVsyncAllowed(/*isAllowed*/ false);
59
60 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
61
62 const auto format = getHasReadbackBuffer() ? mPixelFormat : common::PixelFormat::RGBA_8888;
63
64 ASSERT_NO_FATAL_FAILURE(
65 mTestRenderEngine = std::unique_ptr<TestRenderEngine>(new TestRenderEngine(
66 ::android::renderengine::RenderEngineCreationArgs::Builder()
67 .setPixelFormat(static_cast<int>(format))
68 .setImageCacheSize(TestRenderEngine::sMaxFrameBufferAcquireBuffers)
69 .setEnableProtectedContext(false)
70 .setPrecacheToneMapperShaderOnly(false)
71 .setContextPriority(::android::renderengine::RenderEngine::
72 ContextPriority::HIGH)
73 .build())));
74
75 mClientCompositionDisplaySettings.physicalDisplay =
76 Rect(getDisplayWidth(), getDisplayHeight());
77 mClientCompositionDisplaySettings.clip = mClientCompositionDisplaySettings.physicalDisplay;
78
79 mTestRenderEngine->initGraphicBuffer(
80 static_cast<uint32_t>(getDisplayWidth()), static_cast<uint32_t>(getDisplayHeight()),
81 /*layerCount*/ 1U,
82 static_cast<uint64_t>(
83 static_cast<uint64_t>(common::BufferUsage::CPU_READ_OFTEN) |
84 static_cast<uint64_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
85 static_cast<uint64_t>(common::BufferUsage::GPU_RENDER_TARGET)));
86 mTestRenderEngine->setDisplaySettings(mClientCompositionDisplaySettings);
87 }
88
TearDown()89 void TearDown() override {
90 ASSERT_FALSE(mDisplays.empty());
91 ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
92 ASSERT_TRUE(mComposerClient->tearDown(mWriter.get()));
93 mComposerClient.reset();
94 const auto errors = mReader.takeErrors();
95 ASSERT_TRUE(mReader.takeErrors().empty());
96 ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
97 }
98
getPrimaryDisplay() const99 const VtsDisplay& getPrimaryDisplay() const { return mDisplays[0]; }
100
getPrimaryDisplayId() const101 int64_t getPrimaryDisplayId() const { return getPrimaryDisplay().getDisplayId(); }
102
getInvalidDisplayId() const103 int64_t getInvalidDisplayId() const { return mComposerClient->getInvalidDisplayId(); }
104
getDisplayWidth() const105 int32_t getDisplayWidth() const { return getPrimaryDisplay().getDisplayWidth(); }
106
getDisplayHeight() const107 int32_t getDisplayHeight() const { return getPrimaryDisplay().getDisplayHeight(); }
108
assertServiceSpecificError(const ScopedAStatus & status,int32_t serviceSpecificError)109 void assertServiceSpecificError(const ScopedAStatus& status, int32_t serviceSpecificError) {
110 ASSERT_EQ(status.getExceptionCode(), EX_SERVICE_SPECIFIC);
111 ASSERT_EQ(status.getServiceSpecificError(), serviceSpecificError);
112 }
113
allocateBuffer(uint32_t usage)114 std::pair<bool, ::android::sp<::android::GraphicBuffer>> allocateBuffer(uint32_t usage) {
115 const auto width = static_cast<uint32_t>(getDisplayWidth());
116 const auto height = static_cast<uint32_t>(getDisplayHeight());
117
118 const auto& graphicBuffer = ::android::sp<::android::GraphicBuffer>::make(
119 width, height, ::android::PIXEL_FORMAT_RGBA_8888,
120 /*layerCount*/ 1u, usage, "VtsHalGraphicsComposer3_ReadbackTest");
121
122 if (graphicBuffer && ::android::OK == graphicBuffer->initCheck()) {
123 return {true, graphicBuffer};
124 }
125 return {false, graphicBuffer};
126 }
127
writeLayers(const std::vector<std::shared_ptr<TestLayer>> & layers)128 void writeLayers(const std::vector<std::shared_ptr<TestLayer>>& layers) {
129 for (const auto& layer : layers) {
130 layer->write(*mWriter);
131 }
132 execute();
133 }
134
execute()135 void execute() {
136 auto commands = mWriter->takePendingCommands();
137 if (commands.empty()) {
138 return;
139 }
140
141 auto [status, results] = mComposerClient->executeCommands(commands);
142 ASSERT_TRUE(status.isOk()) << "executeCommands failed " << status.getDescription();
143
144 mReader.parse(std::move(results));
145 }
146
getHasReadbackBuffer()147 bool getHasReadbackBuffer() {
148 auto [status, readBackBufferAttributes] =
149 mComposerClient->getReadbackBufferAttributes(getPrimaryDisplayId());
150 if (status.isOk()) {
151 mPixelFormat = readBackBufferAttributes.format;
152 mDataspace = readBackBufferAttributes.dataspace;
153 return ReadbackHelper::readbackSupported(mPixelFormat, mDataspace);
154 }
155 EXPECT_NO_FATAL_FAILURE(
156 assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
157 return false;
158 }
159
160 std::shared_ptr<VtsComposerClient> mComposerClient;
161 std::vector<VtsDisplay> mDisplays;
162 // use the slot count usually set by SF
163 std::vector<ColorMode> mTestColorModes;
164 std::unique_ptr<ComposerClientWriter> mWriter;
165 ComposerClientReader mReader;
166 std::unique_ptr<TestRenderEngine> mTestRenderEngine;
167 common::PixelFormat mPixelFormat;
168 common::Dataspace mDataspace;
169 ::android::renderengine::DisplaySettings mClientCompositionDisplaySettings;
170
171 static constexpr uint32_t kClientTargetSlotCount = 64;
172
173 private:
setTestColorModes()174 void setTestColorModes() {
175 mTestColorModes.clear();
176 const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
177 ASSERT_TRUE(status.isOk());
178
179 for (ColorMode mode : modes) {
180 if (std::find(ReadbackHelper::colorModes.begin(), ReadbackHelper::colorModes.end(),
181 mode) != ReadbackHelper::colorModes.end()) {
182 mTestColorModes.push_back(mode);
183 }
184 }
185 }
186 };
187
188 class GraphicsCompositionTest : public GraphicsCompositionTestBase,
189 public testing::WithParamInterface<std::string> {
190 public:
SetUp()191 void SetUp() override { SetUpBase(GetParam()); }
192 };
193
TEST_P(GraphicsCompositionTest,SingleSolidColorLayer)194 TEST_P(GraphicsCompositionTest, SingleSolidColorLayer) {
195 for (ColorMode mode : mTestColorModes) {
196 EXPECT_TRUE(mComposerClient
197 ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
198 .isOk());
199
200 bool isSupported;
201 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
202 if (!isSupported) {
203 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
204 return;
205 }
206
207 auto layer =
208 std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
209 common::Rect coloredSquare({0, 0, getDisplayWidth(), getDisplayHeight()});
210 layer->setColor(BLUE);
211 layer->setDisplayFrame(coloredSquare);
212 layer->setZOrder(10);
213
214 std::vector<std::shared_ptr<TestLayer>> layers = {layer};
215
216 // expected color for each pixel
217 std::vector<Color> expectedColors(
218 static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
219 ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), coloredSquare, BLUE);
220
221 ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
222 getDisplayHeight(), mPixelFormat, mDataspace);
223 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
224
225 writeLayers(layers);
226 ASSERT_TRUE(mReader.takeErrors().empty());
227 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
228 VtsComposerClient::kNoFrameIntervalNs);
229 execute();
230 // if hwc cannot handle and asks for composition change,
231 // just succeed the test
232 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
233 GTEST_SUCCEED();
234 return;
235 }
236 ASSERT_TRUE(mReader.takeErrors().empty());
237 mWriter->presentDisplay(getPrimaryDisplayId());
238 execute();
239 ASSERT_TRUE(mReader.takeErrors().empty());
240
241 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
242 mTestRenderEngine->setRenderLayers(layers);
243 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
244 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
245 }
246 }
247
TEST_P(GraphicsCompositionTest,SetLayerBuffer)248 TEST_P(GraphicsCompositionTest, SetLayerBuffer) {
249 for (ColorMode mode : mTestColorModes) {
250 EXPECT_TRUE(mComposerClient
251 ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
252 .isOk());
253
254 bool isSupported;
255 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
256 if (!isSupported) {
257 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
258 return;
259 }
260
261 ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
262 getDisplayHeight(), mPixelFormat, mDataspace);
263 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
264 std::vector<Color> expectedColors(
265 static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
266 ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
267 {0, 0, getDisplayWidth(), getDisplayHeight() / 4}, RED);
268 ReadbackHelper::fillColorsArea(
269 expectedColors, getDisplayWidth(),
270 {0, getDisplayHeight() / 4, getDisplayWidth(), getDisplayHeight() / 2}, GREEN);
271 ReadbackHelper::fillColorsArea(
272 expectedColors, getDisplayWidth(),
273 {0, getDisplayHeight() / 2, getDisplayWidth(), getDisplayHeight()}, BLUE);
274
275 auto layer = std::make_shared<TestBufferLayer>(
276 mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
277 getDisplayHeight(), common::PixelFormat::RGBA_8888, *mWriter);
278 layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
279 layer->setZOrder(10);
280 layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
281 ASSERT_NO_FATAL_FAILURE(layer->setBuffer(expectedColors));
282
283 std::vector<std::shared_ptr<TestLayer>> layers = {layer};
284
285 writeLayers(layers);
286 ASSERT_TRUE(mReader.takeErrors().empty());
287 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
288 VtsComposerClient::kNoFrameIntervalNs);
289 execute();
290
291 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
292 GTEST_SUCCEED();
293 return;
294 }
295 ASSERT_TRUE(mReader.takeErrors().empty());
296
297 mWriter->presentDisplay(getPrimaryDisplayId());
298 execute();
299
300 ASSERT_TRUE(mReader.takeErrors().empty());
301
302 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
303 mTestRenderEngine->setRenderLayers(layers);
304 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
305 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
306 }
307 }
308
TEST_P(GraphicsCompositionTest,SetLayerBufferNoEffect)309 TEST_P(GraphicsCompositionTest, SetLayerBufferNoEffect) {
310 for (ColorMode mode : mTestColorModes) {
311 EXPECT_TRUE(mComposerClient
312 ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
313 .isOk());
314
315 bool isSupported;
316 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
317 if (!isSupported) {
318 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
319 return;
320 }
321
322 auto layer =
323 std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
324 common::Rect coloredSquare({0, 0, getDisplayWidth(), getDisplayHeight()});
325 layer->setColor(BLUE);
326 layer->setDisplayFrame(coloredSquare);
327 layer->setZOrder(10);
328 layer->write(*mWriter);
329
330 // This following buffer call should have no effect
331 const auto usage = static_cast<uint32_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
332 static_cast<uint32_t>(common::BufferUsage::CPU_READ_OFTEN);
333 const auto& [graphicBufferStatus, graphicBuffer] = allocateBuffer(usage);
334 ASSERT_TRUE(graphicBufferStatus);
335 const auto& buffer = graphicBuffer->handle;
336 mWriter->setLayerBuffer(getPrimaryDisplayId(), layer->getLayer(), /*slot*/ 0, buffer,
337 /*acquireFence*/ -1);
338
339 // expected color for each pixel
340 std::vector<Color> expectedColors(
341 static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
342 ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), coloredSquare, BLUE);
343
344 ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
345 getDisplayHeight(), mPixelFormat, mDataspace);
346 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
347
348 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
349 VtsComposerClient::kNoFrameIntervalNs);
350 execute();
351
352 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
353 GTEST_SUCCEED();
354 return;
355 }
356 ASSERT_TRUE(mReader.takeErrors().empty());
357 mWriter->presentDisplay(getPrimaryDisplayId());
358 execute();
359 ASSERT_TRUE(mReader.takeErrors().empty());
360
361 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
362 }
363 }
364
TEST_P(GraphicsCompositionTest,SetReadbackBuffer)365 TEST_P(GraphicsCompositionTest, SetReadbackBuffer) {
366 bool isSupported;
367 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
368 if (!isSupported) {
369 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
370 return;
371 }
372
373 ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
374 getDisplayHeight(), mPixelFormat, mDataspace);
375
376 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
377 }
378
TEST_P(GraphicsCompositionTest,SetReadbackBuffer_BadDisplay)379 TEST_P(GraphicsCompositionTest, SetReadbackBuffer_BadDisplay) {
380 bool isSupported;
381 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
382 if (!isSupported) {
383 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
384 return;
385 }
386
387 const auto usage = static_cast<uint32_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
388 static_cast<uint32_t>(common::BufferUsage::CPU_READ_OFTEN);
389 const auto& [graphicBufferStatus, graphicBuffer] = allocateBuffer(usage);
390 ASSERT_TRUE(graphicBufferStatus);
391 const auto& bufferHandle = graphicBuffer->handle;
392 ::ndk::ScopedFileDescriptor fence = ::ndk::ScopedFileDescriptor(-1);
393
394 const auto status =
395 mComposerClient->setReadbackBuffer(getInvalidDisplayId(), bufferHandle, fence);
396
397 EXPECT_FALSE(status.isOk());
398 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
399 }
400
TEST_P(GraphicsCompositionTest,SetReadbackBuffer_BadParameter)401 TEST_P(GraphicsCompositionTest, SetReadbackBuffer_BadParameter) {
402 bool isSupported;
403 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
404 if (!isSupported) {
405 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
406 return;
407 }
408
409 const native_handle_t bufferHandle{};
410 ndk::ScopedFileDescriptor releaseFence = ndk::ScopedFileDescriptor(-1);
411 const auto status =
412 mComposerClient->setReadbackBuffer(getPrimaryDisplayId(), &bufferHandle, releaseFence);
413
414 EXPECT_FALSE(status.isOk());
415 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
416 }
417
TEST_P(GraphicsCompositionTest,GetReadbackBufferFenceInactive)418 TEST_P(GraphicsCompositionTest, GetReadbackBufferFenceInactive) {
419 bool isSupported;
420 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
421 if (!isSupported) {
422 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
423 return;
424 }
425
426 const auto& [status, releaseFence] =
427 mComposerClient->getReadbackBufferFence(getPrimaryDisplayId());
428
429 EXPECT_FALSE(status.isOk());
430 EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
431 EXPECT_EQ(-1, releaseFence.get());
432 }
433
TEST_P(GraphicsCompositionTest,ClientComposition)434 TEST_P(GraphicsCompositionTest, ClientComposition) {
435 EXPECT_TRUE(
436 mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kClientTargetSlotCount)
437 .isOk());
438
439 for (ColorMode mode : mTestColorModes) {
440 EXPECT_TRUE(mComposerClient
441 ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
442 .isOk());
443
444 bool isSupported;
445 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
446 if (!isSupported) {
447 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
448 return;
449 }
450
451 std::vector<Color> expectedColors(
452 static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
453 ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
454 {0, 0, getDisplayWidth(), getDisplayHeight() / 4}, RED);
455 ReadbackHelper::fillColorsArea(
456 expectedColors, getDisplayWidth(),
457 {0, getDisplayHeight() / 4, getDisplayWidth(), getDisplayHeight() / 2}, GREEN);
458 ReadbackHelper::fillColorsArea(
459 expectedColors, getDisplayWidth(),
460 {0, getDisplayHeight() / 2, getDisplayWidth(), getDisplayHeight()}, BLUE);
461
462 auto layer = std::make_shared<TestBufferLayer>(
463 mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
464 getDisplayHeight(), PixelFormat::RGBA_FP16, *mWriter);
465 layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
466 layer->setZOrder(10);
467 layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
468
469 std::vector<std::shared_ptr<TestLayer>> layers = {layer};
470
471 ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
472 getDisplayHeight(), mPixelFormat, mDataspace);
473 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
474 writeLayers(layers);
475 ASSERT_TRUE(mReader.takeErrors().empty());
476 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
477 VtsComposerClient::kNoFrameIntervalNs);
478 execute();
479
480 auto changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
481 if (!changedCompositionTypes.empty()) {
482 ASSERT_EQ(1, changedCompositionTypes.size());
483 ASSERT_EQ(Composition::CLIENT, changedCompositionTypes[0].composition);
484
485 PixelFormat clientFormat = PixelFormat::RGBA_8888;
486 auto clientUsage = static_cast<uint32_t>(
487 static_cast<uint32_t>(common::BufferUsage::CPU_READ_OFTEN) |
488 static_cast<uint32_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
489 static_cast<uint32_t>(common::BufferUsage::COMPOSER_CLIENT_TARGET));
490 Dataspace clientDataspace = ReadbackHelper::getDataspaceForColorMode(mode);
491 common::Rect damage{0, 0, getDisplayWidth(), getDisplayHeight()};
492
493 // create client target buffer
494 const auto& [graphicBufferStatus, graphicBuffer] = allocateBuffer(clientUsage);
495 ASSERT_TRUE(graphicBufferStatus);
496 const auto& buffer = graphicBuffer->handle;
497 void* clientBufData;
498 const auto stride = static_cast<uint32_t>(graphicBuffer->stride);
499 int bytesPerPixel = -1;
500 int bytesPerStride = -1;
501 graphicBuffer->lock(clientUsage, layer->getAccessRegion(), &clientBufData,
502 &bytesPerPixel, &bytesPerStride);
503
504 ASSERT_NO_FATAL_FAILURE(ReadbackHelper::fillBuffer(
505 layer->getWidth(), layer->getHeight(), stride, bytesPerPixel, clientBufData,
506 clientFormat, expectedColors));
507 int32_t clientFence;
508 const auto unlockStatus = graphicBuffer->unlockAsync(&clientFence);
509 ASSERT_EQ(::android::OK, unlockStatus);
510 mWriter->setClientTarget(getPrimaryDisplayId(), /*slot*/ 0, buffer, clientFence,
511 clientDataspace, std::vector<common::Rect>(1, damage), 1.f);
512 layer->setToClientComposition(*mWriter);
513 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
514 VtsComposerClient::kNoFrameIntervalNs);
515 execute();
516 changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
517 ASSERT_TRUE(changedCompositionTypes.empty());
518 }
519 ASSERT_TRUE(mReader.takeErrors().empty());
520
521 mWriter->presentDisplay(getPrimaryDisplayId());
522 execute();
523
524 ASSERT_TRUE(mReader.takeErrors().empty());
525
526 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
527 }
528 }
529
TEST_P(GraphicsCompositionTest,MixedColorSpaces)530 TEST_P(GraphicsCompositionTest, MixedColorSpaces) {
531 ASSERT_TRUE(
532 mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kClientTargetSlotCount)
533 .isOk());
534 const auto& [status, properties] = mComposerClient->getOverlaySupport();
535 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
536 status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
537 GTEST_SUCCEED() << "getOverlaySupport is not supported";
538 return;
539 }
540
541 if (properties.supportMixedColorSpaces == false) {
542 GTEST_SUCCEED() << "supportMixedColorSpaces is not supported";
543 return;
544 }
545
546 for (ColorMode mode : mTestColorModes) {
547 EXPECT_TRUE(mComposerClient
548 ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
549 .isOk());
550
551 bool isSupported;
552 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
553 if (!isSupported) {
554 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
555 return;
556 }
557
558 // sRGB layer
559 auto srgbLayer = std::make_shared<TestBufferLayer>(
560 mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
561 getDisplayHeight() / 2, PixelFormat::RGBA_8888, *mWriter);
562 std::vector<Color> sRgbDeviceColors(srgbLayer->getWidth() * srgbLayer->getHeight());
563 ReadbackHelper::fillColorsArea(sRgbDeviceColors, getDisplayWidth(),
564 {0, 0, static_cast<int32_t>(srgbLayer->getWidth()),
565 static_cast<int32_t>(srgbLayer->getHeight())},
566 GREEN);
567 srgbLayer->setDisplayFrame({0, 0, static_cast<int32_t>(srgbLayer->getWidth()),
568 static_cast<int32_t>(srgbLayer->getHeight())});
569 srgbLayer->setZOrder(10);
570 srgbLayer->setDataspace(Dataspace::SRGB);
571 ASSERT_NO_FATAL_FAILURE(srgbLayer->setBuffer(sRgbDeviceColors));
572
573 // display P3 layer
574 auto displayP3Layer = std::make_shared<TestBufferLayer>(
575 mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
576 getDisplayHeight() / 2, PixelFormat::RGBA_8888, *mWriter);
577 std::vector<Color> displayP3DeviceColors(
578 static_cast<size_t>(displayP3Layer->getWidth() * displayP3Layer->getHeight()));
579 ReadbackHelper::fillColorsArea(displayP3DeviceColors, getDisplayWidth(),
580 {0, 0, static_cast<int32_t>(displayP3Layer->getWidth()),
581 static_cast<int32_t>(displayP3Layer->getHeight())},
582 RED);
583 displayP3Layer->setDisplayFrame(
584 {0, getDisplayHeight() / 2, getDisplayWidth(), getDisplayHeight()});
585 displayP3Layer->setZOrder(10);
586 displayP3Layer->setDataspace(Dataspace::DISPLAY_P3);
587 ASSERT_NO_FATAL_FAILURE(displayP3Layer->setBuffer(displayP3DeviceColors));
588
589 writeLayers({srgbLayer, displayP3Layer});
590
591 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
592 VtsComposerClient::kNoFrameIntervalNs);
593 execute();
594
595 auto changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
596 ASSERT_TRUE(changedCompositionTypes.empty());
597
598 mWriter->presentDisplay(getPrimaryDisplayId());
599 execute();
600
601 changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
602 ASSERT_TRUE(changedCompositionTypes.empty());
603 ASSERT_TRUE(mReader.takeErrors().empty());
604 }
605 }
606
TEST_P(GraphicsCompositionTest,DeviceAndClientComposition)607 TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) {
608 ASSERT_TRUE(
609 mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kClientTargetSlotCount)
610 .isOk());
611
612 for (ColorMode mode : mTestColorModes) {
613 EXPECT_TRUE(mComposerClient
614 ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
615 .isOk());
616
617 bool isSupported;
618 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
619 if (!isSupported) {
620 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
621 return;
622 }
623
624 std::vector<Color> expectedColors(
625 static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
626 ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
627 {0, 0, getDisplayWidth(), getDisplayHeight() / 2}, GREEN);
628 ReadbackHelper::fillColorsArea(
629 expectedColors, getDisplayWidth(),
630 {0, getDisplayHeight() / 2, getDisplayWidth(), getDisplayHeight()}, RED);
631
632 ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
633 getDisplayHeight(), mPixelFormat, mDataspace);
634 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
635
636 auto deviceLayer = std::make_shared<TestBufferLayer>(
637 mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
638 getDisplayHeight() / 2, PixelFormat::RGBA_8888, *mWriter);
639 std::vector<Color> deviceColors(deviceLayer->getWidth() * deviceLayer->getHeight());
640 ReadbackHelper::fillColorsArea(deviceColors, static_cast<int32_t>(deviceLayer->getWidth()),
641 {0, 0, static_cast<int32_t>(deviceLayer->getWidth()),
642 static_cast<int32_t>(deviceLayer->getHeight())},
643 GREEN);
644 deviceLayer->setDisplayFrame({0, 0, static_cast<int32_t>(deviceLayer->getWidth()),
645 static_cast<int32_t>(deviceLayer->getHeight())});
646 deviceLayer->setZOrder(10);
647 deviceLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
648 ASSERT_NO_FATAL_FAILURE(deviceLayer->setBuffer(deviceColors));
649 deviceLayer->write(*mWriter);
650
651 PixelFormat clientFormat = PixelFormat::RGBA_8888;
652 auto clientUsage = static_cast<uint32_t>(
653 static_cast<uint64_t>(common::BufferUsage::CPU_READ_OFTEN) |
654 static_cast<uint32_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
655 static_cast<uint32_t>(common::BufferUsage::COMPOSER_CLIENT_TARGET));
656 Dataspace clientDataspace = ReadbackHelper::getDataspaceForColorMode(mode);
657 int32_t clientWidth = getDisplayWidth();
658 int32_t clientHeight = getDisplayHeight() / 2;
659
660 auto clientLayer = std::make_shared<TestBufferLayer>(
661 mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), clientWidth,
662 clientHeight, PixelFormat::RGBA_FP16, *mWriter, Composition::DEVICE);
663 common::Rect clientFrame = {0, getDisplayHeight() / 2, getDisplayWidth(),
664 getDisplayHeight()};
665 clientLayer->setDisplayFrame(clientFrame);
666 clientLayer->setZOrder(0);
667 clientLayer->write(*mWriter);
668 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
669 VtsComposerClient::kNoFrameIntervalNs);
670 execute();
671
672 auto changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
673 if (changedCompositionTypes.size() != 1) {
674 continue;
675 }
676 // create client target buffer
677 ASSERT_EQ(Composition::CLIENT, changedCompositionTypes[0].composition);
678 const auto& [graphicBufferStatus, graphicBuffer] = allocateBuffer(clientUsage);
679 ASSERT_TRUE(graphicBufferStatus);
680 const auto& buffer = graphicBuffer->handle;
681
682 void* clientBufData;
683 int bytesPerPixel = -1;
684 int bytesPerStride = -1;
685 graphicBuffer->lock(clientUsage, {0, 0, getDisplayWidth(), getDisplayHeight()},
686 &clientBufData, &bytesPerPixel, &bytesPerStride);
687
688 std::vector<Color> clientColors(
689 static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
690 ReadbackHelper::fillColorsArea(clientColors, getDisplayWidth(), clientFrame, RED);
691 ASSERT_NO_FATAL_FAILURE(ReadbackHelper::fillBuffer(
692 static_cast<uint32_t>(getDisplayWidth()), static_cast<uint32_t>(getDisplayHeight()),
693 graphicBuffer->getStride(), bytesPerPixel, clientBufData, clientFormat,
694 clientColors));
695 int32_t clientFence;
696 const auto unlockStatus = graphicBuffer->unlockAsync(&clientFence);
697 ASSERT_EQ(::android::OK, unlockStatus);
698 mWriter->setClientTarget(getPrimaryDisplayId(), /*slot*/ 0, buffer, clientFence,
699 clientDataspace, std::vector<common::Rect>(1, clientFrame), 1.f);
700 clientLayer->setToClientComposition(*mWriter);
701 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
702 VtsComposerClient::kNoFrameIntervalNs);
703 execute();
704 changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
705 ASSERT_TRUE(changedCompositionTypes.empty());
706 ASSERT_TRUE(mReader.takeErrors().empty());
707
708 mWriter->presentDisplay(getPrimaryDisplayId());
709 execute();
710 ASSERT_TRUE(mReader.takeErrors().empty());
711 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
712 }
713 }
714
TEST_P(GraphicsCompositionTest,SetLayerDamage)715 TEST_P(GraphicsCompositionTest, SetLayerDamage) {
716 for (ColorMode mode : mTestColorModes) {
717 EXPECT_TRUE(mComposerClient
718 ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
719 .isOk());
720
721 bool isSupported;
722 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
723 if (!isSupported) {
724 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
725 return;
726 }
727
728 common::Rect redRect = {0, 0, getDisplayWidth() / 4, getDisplayHeight() / 4};
729
730 std::vector<Color> expectedColors(
731 static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
732 ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), redRect, RED);
733
734 auto layer = std::make_shared<TestBufferLayer>(
735 mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
736 getDisplayHeight(), PixelFormat::RGBA_8888, *mWriter);
737 layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
738 layer->setZOrder(10);
739 layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
740 ASSERT_NO_FATAL_FAILURE(layer->setBuffer(expectedColors));
741
742 std::vector<std::shared_ptr<TestLayer>> layers = {layer};
743
744 ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
745 getDisplayHeight(), mPixelFormat, mDataspace);
746 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
747
748 writeLayers(layers);
749 ASSERT_TRUE(mReader.takeErrors().empty());
750 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
751 VtsComposerClient::kNoFrameIntervalNs);
752 execute();
753 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
754 GTEST_SUCCEED();
755 return;
756 }
757 ASSERT_TRUE(mReader.takeErrors().empty());
758 mWriter->presentDisplay(getPrimaryDisplayId());
759 execute();
760 ASSERT_TRUE(mReader.takeErrors().empty());
761
762 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
763
764 // update surface damage and recheck
765 redRect = {getDisplayWidth() / 4, getDisplayHeight() / 4, getDisplayWidth() / 2,
766 getDisplayHeight() / 2};
767 ReadbackHelper::clearColors(expectedColors, getDisplayWidth(), getDisplayHeight(),
768 getDisplayWidth());
769 ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), redRect, RED);
770
771 ASSERT_NO_FATAL_FAILURE(layer->fillBuffer(expectedColors));
772 layer->setSurfaceDamage(
773 std::vector<common::Rect>(1, {0, 0, getDisplayWidth() / 2, getDisplayWidth() / 2}));
774
775 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
776
777 writeLayers(layers);
778 ASSERT_TRUE(mReader.takeErrors().empty());
779 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
780 VtsComposerClient::kNoFrameIntervalNs);
781 execute();
782 ASSERT_TRUE(mReader.takeErrors().empty());
783 ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
784 mWriter->presentDisplay(getPrimaryDisplayId());
785 execute();
786 ASSERT_TRUE(mReader.takeErrors().empty());
787
788 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
789 }
790 }
791
TEST_P(GraphicsCompositionTest,SetLayerPlaneAlpha)792 TEST_P(GraphicsCompositionTest, SetLayerPlaneAlpha) {
793 for (ColorMode mode : mTestColorModes) {
794 EXPECT_TRUE(mComposerClient
795 ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
796 .isOk());
797
798 bool isSupported;
799 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
800 if (!isSupported) {
801 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
802 return;
803 }
804
805 auto layer =
806 std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
807 layer->setColor(RED);
808 layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
809 layer->setZOrder(10);
810 layer->setAlpha(0);
811 layer->setBlendMode(BlendMode::PREMULTIPLIED);
812
813 std::vector<std::shared_ptr<TestLayer>> layers = {layer};
814
815 ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
816 getDisplayHeight(), mPixelFormat, mDataspace);
817
818 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
819
820 writeLayers(layers);
821 ASSERT_TRUE(mReader.takeErrors().empty());
822 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
823 VtsComposerClient::kNoFrameIntervalNs);
824 execute();
825 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
826 GTEST_SUCCEED();
827 return;
828 }
829 ASSERT_TRUE(mReader.takeErrors().empty());
830
831 mWriter->presentDisplay(getPrimaryDisplayId());
832 execute();
833 ASSERT_TRUE(mReader.takeErrors().empty());
834
835 std::vector<Color> expectedColors(
836 static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
837
838 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
839 mTestRenderEngine->setRenderLayers(layers);
840 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
841 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
842 }
843 }
844
TEST_P(GraphicsCompositionTest,SetLayerSourceCrop)845 TEST_P(GraphicsCompositionTest, SetLayerSourceCrop) {
846 for (ColorMode mode : mTestColorModes) {
847 EXPECT_TRUE(mComposerClient
848 ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
849 .isOk());
850
851 bool isSupported;
852 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
853 if (!isSupported) {
854 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
855 return;
856 }
857
858 std::vector<Color> expectedColors(
859 static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
860 ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
861 {0, 0, getDisplayWidth(), getDisplayHeight() / 4}, RED);
862 ReadbackHelper::fillColorsArea(
863 expectedColors, getDisplayWidth(),
864 {0, getDisplayHeight() / 2, getDisplayWidth(), getDisplayHeight()}, BLUE);
865
866 auto layer = std::make_shared<TestBufferLayer>(
867 mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
868 getDisplayHeight(), PixelFormat::RGBA_8888, *mWriter);
869 layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
870 layer->setZOrder(10);
871 layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
872 layer->setSourceCrop({0, static_cast<float>(getDisplayHeight() / 2),
873 static_cast<float>(getDisplayWidth()),
874 static_cast<float>(getDisplayHeight())});
875 ASSERT_NO_FATAL_FAILURE(layer->setBuffer(expectedColors));
876
877 std::vector<std::shared_ptr<TestLayer>> layers = {layer};
878
879 // update expected colors to match crop
880 ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
881 {0, 0, getDisplayWidth(), getDisplayHeight()}, BLUE);
882 ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
883 getDisplayHeight(), mPixelFormat, mDataspace);
884 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
885 writeLayers(layers);
886 ASSERT_TRUE(mReader.takeErrors().empty());
887 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
888 VtsComposerClient::kNoFrameIntervalNs);
889 execute();
890 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
891 GTEST_SUCCEED();
892 return;
893 }
894 ASSERT_TRUE(mReader.takeErrors().empty());
895 mWriter->presentDisplay(getPrimaryDisplayId());
896 execute();
897 ASSERT_TRUE(mReader.takeErrors().empty());
898 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
899 mTestRenderEngine->setRenderLayers(layers);
900 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
901 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
902 }
903 }
904
TEST_P(GraphicsCompositionTest,SetLayerZOrder)905 TEST_P(GraphicsCompositionTest, SetLayerZOrder) {
906 for (ColorMode mode : mTestColorModes) {
907 EXPECT_TRUE(mComposerClient
908 ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
909 .isOk());
910
911 bool isSupported;
912 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
913 if (!isSupported) {
914 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
915 return;
916 }
917
918 common::Rect redRect = {0, 0, getDisplayWidth(), getDisplayHeight() / 2};
919 common::Rect blueRect = {0, getDisplayHeight() / 4, getDisplayWidth(), getDisplayHeight()};
920 auto redLayer =
921 std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
922 redLayer->setColor(RED);
923 redLayer->setDisplayFrame(redRect);
924
925 auto blueLayer =
926 std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
927 blueLayer->setColor(BLUE);
928 blueLayer->setDisplayFrame(blueRect);
929 blueLayer->setZOrder(5);
930
931 std::vector<std::shared_ptr<TestLayer>> layers = {redLayer, blueLayer};
932 std::vector<Color> expectedColors(
933 static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
934
935 // red in front of blue
936 redLayer->setZOrder(10);
937
938 // fill blue first so that red will overwrite on overlap
939 ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), blueRect, BLUE);
940 ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), redRect, RED);
941
942 ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
943 getDisplayHeight(), mPixelFormat, mDataspace);
944 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
945
946 writeLayers(layers);
947 ASSERT_TRUE(mReader.takeErrors().empty());
948 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
949 VtsComposerClient::kNoFrameIntervalNs);
950 execute();
951 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
952 GTEST_SUCCEED();
953 return;
954 }
955 mWriter->presentDisplay(getPrimaryDisplayId());
956 execute();
957 ASSERT_TRUE(mReader.takeErrors().empty());
958
959 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
960
961 redLayer->setZOrder(1);
962 ReadbackHelper::clearColors(expectedColors, getDisplayWidth(), getDisplayHeight(),
963 getDisplayWidth());
964 ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), redRect, RED);
965 ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), blueRect, BLUE);
966
967 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
968
969 writeLayers(layers);
970 ASSERT_TRUE(mReader.takeErrors().empty());
971 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
972 VtsComposerClient::kNoFrameIntervalNs);
973 execute();
974 ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
975 ASSERT_TRUE(mReader.takeErrors().empty());
976 mWriter->presentDisplay(getPrimaryDisplayId());
977 execute();
978 ASSERT_TRUE(mReader.takeErrors().empty());
979
980 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
981 mTestRenderEngine->setRenderLayers(layers);
982 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
983 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
984 }
985 }
986
TEST_P(GraphicsCompositionTest,SetLayerBrightnessDims)987 TEST_P(GraphicsCompositionTest, SetLayerBrightnessDims) {
988 for (ColorMode mode : mTestColorModes) {
989 EXPECT_TRUE(mComposerClient
990 ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
991 .isOk());
992
993 bool isSupported;
994 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
995 if (!isSupported) {
996 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace for "
997 "color mode: "
998 << toString(mode);
999 continue;
1000 }
1001 const common::Rect redRect = {0, 0, getDisplayWidth(), getDisplayHeight() / 2};
1002 const common::Rect dimmerRedRect = {0, getDisplayHeight() / 2, getDisplayWidth(),
1003 getDisplayHeight()};
1004
1005 static constexpr float kMaxBrightnessNits = 300.f;
1006
1007 const auto redLayer =
1008 std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
1009 redLayer->setColor(RED);
1010 redLayer->setDisplayFrame(redRect);
1011 redLayer->setWhitePointNits(kMaxBrightnessNits);
1012 redLayer->setBrightness(1.f);
1013
1014 const auto dimmerRedLayer =
1015 std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
1016 dimmerRedLayer->setColor(RED);
1017 dimmerRedLayer->setDisplayFrame(dimmerRedRect);
1018 // Intentionally use a small dimming ratio as some implementations may be more likely to
1019 // kick into GPU composition to apply dithering when the dimming ratio is high.
1020 static constexpr float kDimmingRatio = 0.9f;
1021 dimmerRedLayer->setWhitePointNits(kMaxBrightnessNits * kDimmingRatio);
1022 dimmerRedLayer->setBrightness(kDimmingRatio);
1023
1024 const std::vector<std::shared_ptr<TestLayer>> layers = {redLayer, dimmerRedLayer};
1025 std::vector<Color> expectedColors(
1026 static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
1027
1028 ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), redRect, RED);
1029 ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(), dimmerRedRect, DIM_RED);
1030
1031 ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
1032 getDisplayHeight(), mPixelFormat, mDataspace);
1033 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
1034
1035 writeLayers(layers);
1036 ASSERT_TRUE(mReader.takeErrors().empty());
1037 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1038 VtsComposerClient::kNoFrameIntervalNs);
1039 execute();
1040 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
1041 GTEST_SUCCEED()
1042 << "Readback verification not supported for GPU composition for color mode: "
1043 << toString(mode);
1044 continue;
1045 }
1046 mWriter->presentDisplay(getPrimaryDisplayId());
1047 execute();
1048 ASSERT_TRUE(mReader.takeErrors().empty());
1049
1050 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
1051 mTestRenderEngine->setRenderLayers(layers);
1052 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
1053 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
1054 }
1055 }
1056
1057 class GraphicsBlendModeCompositionTest
1058 : public GraphicsCompositionTestBase,
1059 public testing::WithParamInterface<std::tuple<std::string, std::string>> {
1060 public:
SetUp()1061 void SetUp() override {
1062 SetUpBase(std::get<0>(GetParam()));
1063 // TODO(b/219590743) we should remove the below SRGB color mode
1064 // once we have the BlendMode test fix for all the versions of the ColorMode
1065 mTestColorModes.erase(
1066 std::remove_if(mTestColorModes.begin(), mTestColorModes.end(),
1067 [](ColorMode mode) { return mode != ColorMode::SRGB; }),
1068 mTestColorModes.end());
1069 mBackgroundColor = BLACK;
1070 mTopLayerColor = RED;
1071 }
1072
setBackgroundColor(Color color)1073 void setBackgroundColor(Color color) { mBackgroundColor = color; }
1074
setTopLayerColor(Color color)1075 void setTopLayerColor(Color color) { mTopLayerColor = color; }
1076
setUpLayers(BlendMode blendMode)1077 void setUpLayers(BlendMode blendMode) {
1078 mLayers.clear();
1079 std::vector<Color> topLayerPixelColors(
1080 static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
1081 ReadbackHelper::fillColorsArea(topLayerPixelColors, getDisplayWidth(),
1082 {0, 0, getDisplayWidth(), getDisplayHeight()},
1083 mTopLayerColor);
1084
1085 auto backgroundLayer =
1086 std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
1087 backgroundLayer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
1088 backgroundLayer->setZOrder(0);
1089 backgroundLayer->setColor(mBackgroundColor);
1090
1091 auto layer = std::make_shared<TestBufferLayer>(
1092 mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
1093 getDisplayHeight(), PixelFormat::RGBA_8888, *mWriter);
1094 layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
1095 layer->setZOrder(10);
1096 layer->setDataspace(Dataspace::UNKNOWN);
1097 ASSERT_NO_FATAL_FAILURE(layer->setBuffer(topLayerPixelColors));
1098
1099 layer->setBlendMode(blendMode);
1100 layer->setAlpha(std::stof(std::get<1>(GetParam())));
1101
1102 mLayers.push_back(backgroundLayer);
1103 mLayers.push_back(layer);
1104 }
1105
setExpectedColors(std::vector<Color> & expectedColors)1106 void setExpectedColors(std::vector<Color>& expectedColors) {
1107 ASSERT_EQ(2, mLayers.size());
1108 ReadbackHelper::clearColors(expectedColors, getDisplayWidth(), getDisplayHeight(),
1109 getDisplayWidth());
1110
1111 auto layer = mLayers[1];
1112 BlendMode blendMode = layer->getBlendMode();
1113 float alpha = mTopLayerColor.a * layer->getAlpha();
1114 if (blendMode == BlendMode::NONE) {
1115 for (auto& expectedColor : expectedColors) {
1116 expectedColor.r = mTopLayerColor.r * layer->getAlpha();
1117 expectedColor.g = mTopLayerColor.g * layer->getAlpha();
1118 expectedColor.b = mTopLayerColor.b * layer->getAlpha();
1119 expectedColor.a = alpha;
1120 }
1121 } else if (blendMode == BlendMode::PREMULTIPLIED) {
1122 for (auto& expectedColor : expectedColors) {
1123 expectedColor.r =
1124 mTopLayerColor.r * layer->getAlpha() + mBackgroundColor.r * (1.0f - alpha);
1125 expectedColor.g =
1126 mTopLayerColor.g * layer->getAlpha() + mBackgroundColor.g * (1.0f - alpha);
1127 expectedColor.b =
1128 mTopLayerColor.b * layer->getAlpha() + mBackgroundColor.b * (1.0f - alpha);
1129 expectedColor.a = alpha + mBackgroundColor.a * (1.0f - alpha);
1130 }
1131 } else if (blendMode == BlendMode::COVERAGE) {
1132 for (auto& expectedColor : expectedColors) {
1133 expectedColor.r = mTopLayerColor.r * alpha + mBackgroundColor.r * (1.0f - alpha);
1134 expectedColor.g = mTopLayerColor.g * alpha + mBackgroundColor.g * (1.0f - alpha);
1135 expectedColor.b = mTopLayerColor.b * alpha + mBackgroundColor.b * (1.0f - alpha);
1136 expectedColor.a = mTopLayerColor.a * alpha + mBackgroundColor.a * (1.0f - alpha);
1137 }
1138 }
1139 }
1140
1141 protected:
1142 std::vector<std::shared_ptr<TestLayer>> mLayers;
1143 Color mBackgroundColor;
1144 Color mTopLayerColor;
1145 };
1146
TEST_P(GraphicsBlendModeCompositionTest,None)1147 TEST_P(GraphicsBlendModeCompositionTest, None) {
1148 for (ColorMode mode : mTestColorModes) {
1149 EXPECT_TRUE(mComposerClient
1150 ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
1151 .isOk());
1152
1153 bool isSupported;
1154 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
1155 if (!isSupported) {
1156 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
1157 return;
1158 }
1159
1160 std::vector<Color> expectedColors(
1161 static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
1162
1163 setBackgroundColor(BLACK);
1164 setTopLayerColor(TRANSLUCENT_RED);
1165 setUpLayers(BlendMode::NONE);
1166 setExpectedColors(expectedColors);
1167
1168 ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
1169 getDisplayHeight(), mPixelFormat, mDataspace);
1170 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
1171 writeLayers(mLayers);
1172 ASSERT_TRUE(mReader.takeErrors().empty());
1173 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1174 VtsComposerClient::kNoFrameIntervalNs);
1175 execute();
1176 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
1177 GTEST_SUCCEED();
1178 return;
1179 }
1180 ASSERT_TRUE(mReader.takeErrors().empty());
1181 mWriter->presentDisplay(getPrimaryDisplayId());
1182 execute();
1183 ASSERT_TRUE(mReader.takeErrors().empty());
1184
1185 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
1186 mTestRenderEngine->setRenderLayers(mLayers);
1187 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
1188 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
1189 }
1190 }
1191
TEST_P(GraphicsBlendModeCompositionTest,Coverage)1192 TEST_P(GraphicsBlendModeCompositionTest, Coverage) {
1193 for (ColorMode mode : mTestColorModes) {
1194 EXPECT_TRUE(mComposerClient
1195 ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
1196 .isOk());
1197
1198 bool isSupported;
1199 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
1200 if (!isSupported) {
1201 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
1202 return;
1203 }
1204
1205 std::vector<Color> expectedColors(
1206 static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
1207
1208 setBackgroundColor(BLACK);
1209 setTopLayerColor(TRANSLUCENT_RED);
1210
1211 setUpLayers(BlendMode::COVERAGE);
1212 setExpectedColors(expectedColors);
1213
1214 ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
1215 getDisplayHeight(), mPixelFormat, mDataspace);
1216 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
1217 writeLayers(mLayers);
1218 ASSERT_TRUE(mReader.takeErrors().empty());
1219 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1220 VtsComposerClient::kNoFrameIntervalNs);
1221 execute();
1222 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
1223 GTEST_SUCCEED();
1224 return;
1225 }
1226 ASSERT_TRUE(mReader.takeErrors().empty());
1227 mWriter->presentDisplay(getPrimaryDisplayId());
1228 execute();
1229 ASSERT_TRUE(mReader.takeErrors().empty());
1230 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
1231 }
1232 }
1233
TEST_P(GraphicsBlendModeCompositionTest,Premultiplied)1234 TEST_P(GraphicsBlendModeCompositionTest, Premultiplied) {
1235 for (ColorMode mode : mTestColorModes) {
1236 EXPECT_TRUE(mComposerClient
1237 ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
1238 .isOk());
1239
1240 bool isSupported;
1241 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
1242 if (!isSupported) {
1243 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
1244 return;
1245 }
1246
1247 std::vector<Color> expectedColors(
1248 static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
1249
1250 setBackgroundColor(BLACK);
1251 setTopLayerColor(TRANSLUCENT_RED);
1252 setUpLayers(BlendMode::PREMULTIPLIED);
1253 setExpectedColors(expectedColors);
1254
1255 ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
1256 getDisplayHeight(), mPixelFormat, mDataspace);
1257 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
1258 writeLayers(mLayers);
1259 ASSERT_TRUE(mReader.takeErrors().empty());
1260 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1261 VtsComposerClient::kNoFrameIntervalNs);
1262 execute();
1263 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
1264 GTEST_SUCCEED();
1265 return;
1266 }
1267 ASSERT_TRUE(mReader.takeErrors().empty());
1268 mWriter->presentDisplay(getPrimaryDisplayId());
1269 execute();
1270 ASSERT_TRUE(mReader.takeErrors().empty());
1271 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
1272 mTestRenderEngine->setRenderLayers(mLayers);
1273 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
1274 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
1275 }
1276 }
1277
1278 class GraphicsTransformCompositionTest : public GraphicsCompositionTest {
1279 protected:
SetUp()1280 void SetUp() override {
1281 GraphicsCompositionTest::SetUp();
1282
1283 auto backgroundLayer =
1284 std::make_shared<TestColorLayer>(mComposerClient, getPrimaryDisplayId(), *mWriter);
1285 backgroundLayer->setColor({0.0f, 0.0f, 0.0f, 0.0f});
1286 backgroundLayer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
1287 backgroundLayer->setZOrder(0);
1288
1289 mSideLength =
1290 getDisplayWidth() < getDisplayHeight() ? getDisplayWidth() : getDisplayHeight();
1291 common::Rect redRect = {0, 0, mSideLength / 2, mSideLength / 2};
1292 common::Rect blueRect = {mSideLength / 2, mSideLength / 2, mSideLength, mSideLength};
1293
1294 mLayer = std::make_shared<TestBufferLayer>(mComposerClient, *mTestRenderEngine,
1295 getPrimaryDisplayId(), mSideLength, mSideLength,
1296 PixelFormat::RGBA_8888, *mWriter);
1297 mLayer->setDisplayFrame({0, 0, mSideLength, mSideLength});
1298 mLayer->setZOrder(10);
1299
1300 std::vector<Color> baseColors(static_cast<size_t>(mSideLength * mSideLength));
1301 ReadbackHelper::fillColorsArea(baseColors, mSideLength, redRect, RED);
1302 ReadbackHelper::fillColorsArea(baseColors, mSideLength, blueRect, BLUE);
1303 ASSERT_NO_FATAL_FAILURE(mLayer->setBuffer(baseColors));
1304 mLayers = {backgroundLayer, mLayer};
1305 }
1306
1307 protected:
1308 std::shared_ptr<TestBufferLayer> mLayer;
1309 std::vector<std::shared_ptr<TestLayer>> mLayers;
1310 int mSideLength;
1311 };
1312
TEST_P(GraphicsTransformCompositionTest,FLIP_H)1313 TEST_P(GraphicsTransformCompositionTest, FLIP_H) {
1314 for (ColorMode mode : mTestColorModes) {
1315 auto status = mComposerClient->setColorMode(getPrimaryDisplayId(), mode,
1316 RenderIntent::COLORIMETRIC);
1317 if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
1318 (status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED ||
1319 status.getServiceSpecificError() == IComposerClient::EX_BAD_PARAMETER)) {
1320 SUCCEED() << "ColorMode not supported, skip test";
1321 return;
1322 }
1323
1324 bool isSupported;
1325 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
1326 if (!isSupported) {
1327 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
1328 return;
1329 }
1330 ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
1331 getDisplayHeight(), mPixelFormat, mDataspace);
1332 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
1333 mLayer->setTransform(Transform::FLIP_H);
1334 mLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
1335
1336 std::vector<Color> expectedColors(
1337 static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
1338 ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
1339 {mSideLength / 2, 0, mSideLength, mSideLength / 2}, RED);
1340 ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
1341 {0, mSideLength / 2, mSideLength / 2, mSideLength}, BLUE);
1342
1343 writeLayers(mLayers);
1344 ASSERT_TRUE(mReader.takeErrors().empty());
1345 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1346 VtsComposerClient::kNoFrameIntervalNs);
1347 execute();
1348 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
1349 GTEST_SUCCEED();
1350 return;
1351 }
1352 ASSERT_TRUE(mReader.takeErrors().empty());
1353 mWriter->presentDisplay(getPrimaryDisplayId());
1354 execute();
1355 ASSERT_TRUE(mReader.takeErrors().empty());
1356
1357 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
1358 mTestRenderEngine->setRenderLayers(mLayers);
1359 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
1360 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
1361 }
1362 }
1363
TEST_P(GraphicsTransformCompositionTest,FLIP_V)1364 TEST_P(GraphicsTransformCompositionTest, FLIP_V) {
1365 for (ColorMode mode : mTestColorModes) {
1366 EXPECT_TRUE(mComposerClient
1367 ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
1368 .isOk());
1369
1370 bool isSupported;
1371 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
1372 if (!isSupported) {
1373 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
1374 return;
1375 }
1376 ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
1377 getDisplayHeight(), mPixelFormat, mDataspace);
1378 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
1379
1380 mLayer->setTransform(Transform::FLIP_V);
1381 mLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
1382
1383 std::vector<Color> expectedColors(
1384 static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
1385 ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
1386 {0, mSideLength / 2, mSideLength / 2, mSideLength}, RED);
1387 ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
1388 {mSideLength / 2, 0, mSideLength, mSideLength / 2}, BLUE);
1389
1390 writeLayers(mLayers);
1391 ASSERT_TRUE(mReader.takeErrors().empty());
1392 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1393 VtsComposerClient::kNoFrameIntervalNs);
1394 execute();
1395 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
1396 GTEST_SUCCEED();
1397 return;
1398 }
1399 ASSERT_TRUE(mReader.takeErrors().empty());
1400 mWriter->presentDisplay(getPrimaryDisplayId());
1401 execute();
1402 ASSERT_TRUE(mReader.takeErrors().empty());
1403 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
1404 mTestRenderEngine->setRenderLayers(mLayers);
1405 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
1406 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
1407 }
1408 }
1409
TEST_P(GraphicsTransformCompositionTest,ROT_180)1410 TEST_P(GraphicsTransformCompositionTest, ROT_180) {
1411 for (ColorMode mode : mTestColorModes) {
1412 EXPECT_TRUE(mComposerClient
1413 ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
1414 .isOk());
1415
1416 bool isSupported;
1417 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
1418 if (!isSupported) {
1419 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
1420 return;
1421 }
1422 ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
1423 getDisplayHeight(), mPixelFormat, mDataspace);
1424 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
1425
1426 mLayer->setTransform(Transform::ROT_180);
1427 mLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
1428
1429 std::vector<Color> expectedColors(
1430 static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
1431 ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
1432 {mSideLength / 2, mSideLength / 2, mSideLength, mSideLength},
1433 RED);
1434 ReadbackHelper::fillColorsArea(expectedColors, getDisplayWidth(),
1435 {0, 0, mSideLength / 2, mSideLength / 2}, BLUE);
1436
1437 writeLayers(mLayers);
1438 ASSERT_TRUE(mReader.takeErrors().empty());
1439 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1440 VtsComposerClient::kNoFrameIntervalNs);
1441 execute();
1442 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
1443 GTEST_SUCCEED();
1444 return;
1445 }
1446 ASSERT_TRUE(mReader.takeErrors().empty());
1447 mWriter->presentDisplay(getPrimaryDisplayId());
1448 execute();
1449 ASSERT_TRUE(mReader.takeErrors().empty());
1450 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
1451 mTestRenderEngine->setRenderLayers(mLayers);
1452 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
1453 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
1454 }
1455 }
1456
1457 class GraphicsColorManagementCompositionTest
1458 : public GraphicsCompositionTestBase,
1459 public testing::WithParamInterface<std::tuple<std::string, Dataspace, Dataspace, Dataspace>> {
1460 public:
SetUp()1461 void SetUp() override {
1462 SetUpBase(std::get<0>(GetParam()));
1463 // for some reason only sRGB reliably works
1464 mTestColorModes.erase(
1465 std::remove_if(mTestColorModes.begin(), mTestColorModes.end(),
1466 [](ColorMode mode) { return mode != ColorMode::SRGB; }),
1467 mTestColorModes.end());
1468 auto standard = std::get<1>(GetParam());
1469 auto transfer = std::get<2>(GetParam());
1470 auto range = std::get<3>(GetParam());
1471
1472 mLayerDataspace = static_cast<Dataspace>(static_cast<int32_t>(standard) |
1473 static_cast<int32_t>(transfer) |
1474 static_cast<int32_t>(range));
1475 ALOGD("Invoking test for dataspace: {%s, %s, %s}", toString(standard).c_str(),
1476 toString(transfer).c_str(), toString(range).c_str());
1477 }
1478
makeLayer()1479 void makeLayer() {
1480 mLayer = std::make_shared<TestBufferLayer>(
1481 mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
1482 getDisplayHeight(), common::PixelFormat::RGBA_8888, *mWriter);
1483 mLayer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
1484 mLayer->setZOrder(10);
1485 mLayer->setAlpha(1.f);
1486 mLayer->setDataspace(mLayerDataspace);
1487 }
1488
fillColor(Color color)1489 void fillColor(Color color) {
1490 std::vector<Color> baseColors(static_cast<size_t>(getDisplayWidth() * getDisplayHeight()));
1491 ReadbackHelper::fillColorsArea(baseColors, getDisplayWidth(),
1492 common::Rect{.left = 0,
1493 .top = 0,
1494 .right = getDisplayWidth(),
1495 .bottom = getDisplayHeight()},
1496 color);
1497 ASSERT_NO_FATAL_FAILURE(mLayer->setBuffer(baseColors));
1498 }
1499
1500 Dataspace mLayerDataspace;
1501 std::shared_ptr<TestBufferLayer> mLayer;
1502 };
1503
TEST_P(GraphicsColorManagementCompositionTest,ColorConversion)1504 TEST_P(GraphicsColorManagementCompositionTest, ColorConversion) {
1505 for (ColorMode mode : mTestColorModes) {
1506 EXPECT_TRUE(mComposerClient
1507 ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
1508 .isOk());
1509
1510 bool isSupported;
1511 ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
1512 if (!isSupported) {
1513 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
1514 return;
1515 }
1516
1517 mClientCompositionDisplaySettings.outputDataspace =
1518 static_cast<::android::ui::Dataspace>(mDataspace);
1519 mTestRenderEngine->setDisplaySettings(mClientCompositionDisplaySettings);
1520
1521 makeLayer();
1522 for (auto color : {LIGHT_RED, LIGHT_GREEN, LIGHT_BLUE}) {
1523 ALOGD("Testing color: %f, %f, %f, %f with color mode: %d", color.r, color.g, color.b,
1524 color.a, mode);
1525 ReadbackBuffer readbackBuffer(getPrimaryDisplayId(), mComposerClient, getDisplayWidth(),
1526 getDisplayHeight(), mPixelFormat, mDataspace);
1527 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
1528 fillColor(color);
1529 writeLayers({mLayer});
1530 EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
1531
1532 ASSERT_TRUE(mReader.takeErrors().empty());
1533 mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
1534 VtsComposerClient::kNoFrameIntervalNs);
1535 execute();
1536 if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
1537 continue;
1538 }
1539 ASSERT_TRUE(mReader.takeErrors().empty());
1540 mWriter->presentDisplay(getPrimaryDisplayId());
1541 execute();
1542 ASSERT_TRUE(mReader.takeErrors().empty());
1543
1544 mTestRenderEngine->setRenderLayers({mLayer});
1545 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
1546 ASSERT_NO_FATAL_FAILURE(
1547 mTestRenderEngine->checkColorBuffer(readbackBuffer.getBuffer()));
1548 }
1549 }
1550 }
1551
1552 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsCompositionTest);
1553 INSTANTIATE_TEST_SUITE_P(
1554 PerInstance, GraphicsCompositionTest,
1555 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
1556 ::android::PrintInstanceNameToString);
1557
1558 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsBlendModeCompositionTest);
1559 INSTANTIATE_TEST_SUITE_P(BlendMode, GraphicsBlendModeCompositionTest,
1560 testing::Combine(testing::ValuesIn(::android::getAidlHalInstanceNames(
1561 IComposer::descriptor)),
1562 testing::Values("0.2", "1.0")));
1563
1564 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsTransformCompositionTest);
1565 INSTANTIATE_TEST_SUITE_P(
1566 PerInstance, GraphicsTransformCompositionTest,
1567 testing::ValuesIn(::android::getAidlHalInstanceNames(IComposer::descriptor)),
1568 ::android::PrintInstanceNameToString);
1569
1570 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsColorManagementCompositionTest);
1571 INSTANTIATE_TEST_SUITE_P(PerInstance, GraphicsColorManagementCompositionTest,
1572 testing::Combine(testing::ValuesIn(::android::getAidlHalInstanceNames(
1573 IComposer::descriptor)),
1574 // Only check sRGB, but verify that extended range
1575 // doesn't trigger any gamma shifts
1576 testing::Values(Dataspace::STANDARD_BT709),
1577 testing::Values(Dataspace::TRANSFER_SRGB),
1578 // Don't test limited range until we send YUV overlays
1579 testing::Values(Dataspace::RANGE_FULL,
1580 Dataspace::RANGE_EXTENDED)));
1581
1582 } // namespace
1583 } // namespace aidl::android::hardware::graphics::composer3::vts
1584