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