1 /*
2 * Copyright 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "graphics_composer_hidl_hal_readback_tests@2.2"
18
19 #include <composer-command-buffer/2.2/ComposerCommandBuffer.h>
20 #include <composer-vts/2.1/GraphicsComposerCallback.h>
21 #include <composer-vts/2.1/TestCommandReader.h>
22 #include <composer-vts/2.2/ComposerVts.h>
23 #include <composer-vts/2.2/ReadbackVts.h>
24 #include <composer-vts/2.2/RenderEngineVts.h>
25 #include <gtest/gtest.h>
26 #include <hidl/GtestPrinter.h>
27 #include <hidl/ServiceManagement.h>
28 #include <ui/GraphicBuffer.h>
29 #include <ui/GraphicBufferAllocator.h>
30 #include <ui/PixelFormat.h>
31 #include <ui/Rect.h>
32 #include <ui/Region.h>
33
34 namespace android {
35 namespace hardware {
36 namespace graphics {
37 namespace composer {
38 namespace V2_2 {
39 namespace vts {
40 namespace {
41
42 using android::Rect;
43 using common::V1_1::BufferUsage;
44 using common::V1_1::Dataspace;
45 using common::V1_1::PixelFormat;
46 using V2_1::Config;
47 using V2_1::Display;
48 using V2_1::vts::NativeHandleWrapper;
49 using V2_1::vts::TestCommandReader;
50 using vts::Gralloc;
51
52 class GraphicsCompositionTestBase : public ::testing::Test {
53 protected:
54 using PowerMode = V2_1::IComposerClient::PowerMode;
SetUpBase(const std::string & service_name)55 void SetUpBase(const std::string& service_name) {
56 ASSERT_NO_FATAL_FAILURE(
57 mComposer = std::make_unique<Composer>(IComposer::getService(service_name)));
58 ASSERT_NO_FATAL_FAILURE(mComposerClient = mComposer->createClient());
59 mComposerCallback = new V2_1::vts::GraphicsComposerCallback;
60 mComposerClient->registerCallback(mComposerCallback);
61
62 // assume the first display is primary and is never removed
63 mPrimaryDisplay = waitForFirstDisplay();
64 Config activeConfig;
65 ASSERT_NO_FATAL_FAILURE(activeConfig = mComposerClient->getActiveConfig(mPrimaryDisplay));
66 ASSERT_NO_FATAL_FAILURE(
67 mDisplayWidth = mComposerClient->getDisplayAttribute(
68 mPrimaryDisplay, activeConfig, IComposerClient::Attribute::WIDTH));
69 ASSERT_NO_FATAL_FAILURE(
70 mDisplayHeight = mComposerClient->getDisplayAttribute(
71 mPrimaryDisplay, activeConfig, IComposerClient::Attribute::HEIGHT));
72
73 setTestColorModes();
74
75 // explicitly disable vsync
76 ASSERT_NO_FATAL_FAILURE(mComposerClient->setVsyncEnabled(mPrimaryDisplay, false));
77 mComposerCallback->setVsyncAllowed(false);
78
79 // set up command writer/reader and gralloc
80 mWriter = std::make_shared<CommandWriterBase>(1024);
81 mReader = std::make_unique<TestCommandReader>();
82 mGralloc = std::make_shared<Gralloc>();
83
84 ASSERT_NO_FATAL_FAILURE(mComposerClient->setPowerMode(mPrimaryDisplay, PowerMode::ON));
85
86 ASSERT_NO_FATAL_FAILURE(
87 mTestRenderEngine = std::unique_ptr<TestRenderEngine>(new TestRenderEngine(
88 renderengine::RenderEngineCreationArgs::Builder()
89 .setPixelFormat(static_cast<int>(ui::PixelFormat::RGBA_8888))
90 .setImageCacheSize(TestRenderEngine::sMaxFrameBufferAcquireBuffers)
91 .setUseColorManagerment(true)
92 .setEnableProtectedContext(false)
93 .setPrecacheToneMapperShaderOnly(false)
94 .setContextPriority(renderengine::RenderEngine::ContextPriority::HIGH)
95 .build())));
96
97 renderengine::DisplaySettings clientCompositionDisplay;
98 clientCompositionDisplay.physicalDisplay = Rect(mDisplayWidth, mDisplayHeight);
99 clientCompositionDisplay.clip = clientCompositionDisplay.physicalDisplay;
100
101 mTestRenderEngine->initGraphicBuffer(
102 static_cast<uint32_t>(mDisplayWidth), static_cast<uint32_t>(mDisplayHeight), 1,
103 static_cast<uint64_t>(BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN |
104 BufferUsage::GPU_RENDER_TARGET));
105 mTestRenderEngine->setDisplaySettings(clientCompositionDisplay);
106 }
107
TearDown()108 void TearDown() override {
109 ASSERT_NO_FATAL_FAILURE(mComposerClient->setPowerMode(mPrimaryDisplay, PowerMode::OFF));
110 EXPECT_EQ(0, mReader->mErrors.size());
111 EXPECT_EQ(0, mReader->mCompositionChanges.size());
112 if (mComposerCallback != nullptr) {
113 EXPECT_EQ(0, mComposerCallback->getInvalidHotplugCount());
114 EXPECT_EQ(0, mComposerCallback->getInvalidRefreshCount());
115 EXPECT_EQ(0, mComposerCallback->getInvalidVsyncCount());
116 }
117 }
118
clearCommandReaderState()119 void clearCommandReaderState() {
120 mReader->mCompositionChanges.clear();
121 mReader->mErrors.clear();
122 }
123
writeLayers(const std::vector<std::shared_ptr<TestLayer>> & layers)124 void writeLayers(const std::vector<std::shared_ptr<TestLayer>>& layers) {
125 for (auto layer : layers) {
126 layer->write(mWriter);
127 }
128 execute();
129 }
130
execute()131 void execute() {
132 ASSERT_NO_FATAL_FAILURE(mComposerClient->execute(mReader.get(), mWriter.get()));
133 }
134
135 std::unique_ptr<Composer> mComposer;
136 std::shared_ptr<ComposerClient> mComposerClient;
137
138 sp<V2_1::vts::GraphicsComposerCallback> mComposerCallback;
139 // the first display and is assumed never to be removed
140 Display mPrimaryDisplay;
141 int32_t mDisplayWidth;
142 int32_t mDisplayHeight;
143 std::vector<ColorMode> mTestColorModes;
144 std::shared_ptr<CommandWriterBase> mWriter;
145 std::unique_ptr<TestCommandReader> mReader;
146 std::shared_ptr<Gralloc> mGralloc;
147 std::unique_ptr<TestRenderEngine> mTestRenderEngine;
148
149 bool mHasReadbackBuffer;
150 PixelFormat mPixelFormat;
151 Dataspace mDataspace;
152
153 static constexpr uint32_t kClientTargetSlotCount = 64;
154
155 private:
waitForFirstDisplay()156 Display waitForFirstDisplay() {
157 while (true) {
158 std::vector<Display> displays = mComposerCallback->getDisplays();
159 if (displays.empty()) {
160 usleep(5 * 1000);
161 continue;
162 }
163 return displays[0];
164 }
165 }
166
setTestColorModes()167 void setTestColorModes() {
168 mTestColorModes.clear();
169 mComposerClient->getRaw()->getColorModes_2_2(mPrimaryDisplay, [&](const auto& tmpError,
170 const auto& tmpModes) {
171 ASSERT_EQ(Error::NONE, tmpError);
172 for (ColorMode mode : tmpModes) {
173 if (std::find(ReadbackHelper::colorModes.begin(), ReadbackHelper::colorModes.end(),
174 mode) != ReadbackHelper::colorModes.end()) {
175 mTestColorModes.push_back(mode);
176 }
177 }
178 });
179 }
180 };
181
182 class GraphicsCompositionTest : public GraphicsCompositionTestBase,
183 public testing::WithParamInterface<std::string> {
184 public:
SetUp()185 void SetUp() override { SetUpBase(GetParam()); }
186 };
187
TEST_P(GraphicsCompositionTest,SingleSolidColorLayer)188 TEST_P(GraphicsCompositionTest, SingleSolidColorLayer) {
189 for (ColorMode mode : mTestColorModes) {
190 std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"
191 << std::endl;
192 mWriter->selectDisplay(mPrimaryDisplay);
193 ASSERT_NO_FATAL_FAILURE(
194 mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
195
196 mComposerClient->getRaw()->getReadbackBufferAttributes(
197 mPrimaryDisplay,
198 [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {
199 mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,
200 tmpDataspace, tmpError);
201 mPixelFormat = tmpPixelFormat;
202 mDataspace = tmpDataspace;
203 });
204
205 if (!mHasReadbackBuffer) {
206 std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;
207 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
208 return;
209 }
210
211 auto layer = std::make_shared<TestColorLayer>(mComposerClient, mPrimaryDisplay);
212 IComposerClient::Rect coloredSquare({0, 0, mDisplayWidth, mDisplayHeight});
213 layer->setColor(BLUE);
214 layer->setDisplayFrame(coloredSquare);
215 layer->setZOrder(10);
216
217 std::vector<std::shared_ptr<TestLayer>> layers = {layer};
218
219 // expected color for each pixel
220 std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);
221 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, coloredSquare, BLUE);
222
223 ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth,
224 mDisplayHeight, mPixelFormat, mDataspace);
225 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
226
227 writeLayers(layers);
228 ASSERT_EQ(0, mReader->mErrors.size());
229 mWriter->validateDisplay();
230 execute();
231 // if hwc cannot handle and asks for composition change,
232 // just succeed the test
233 if (mReader->mCompositionChanges.size() != 0) {
234 clearCommandReaderState();
235 GTEST_SUCCEED();
236 return;
237 }
238 ASSERT_EQ(0, mReader->mErrors.size());
239 mWriter->presentDisplay();
240 execute();
241 ASSERT_EQ(0, mReader->mErrors.size());
242
243 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
244 mTestRenderEngine->setRenderLayers(layers);
245 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
246 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
247 }
248 }
249
TEST_P(GraphicsCompositionTest,SetLayerBuffer)250 TEST_P(GraphicsCompositionTest, SetLayerBuffer) {
251 for (ColorMode mode : mTestColorModes) {
252 std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"
253 << std::endl;
254 mWriter->selectDisplay(mPrimaryDisplay);
255 ASSERT_NO_FATAL_FAILURE(
256 mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
257
258 mComposerClient->getRaw()->getReadbackBufferAttributes(
259 mPrimaryDisplay,
260 [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {
261 mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,
262 tmpDataspace, tmpError);
263 mPixelFormat = tmpPixelFormat;
264 mDataspace = tmpDataspace;
265 });
266
267 if (!mHasReadbackBuffer) {
268 std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;
269 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
270 return;
271 }
272
273 mWriter->selectDisplay(mPrimaryDisplay);
274
275 ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth,
276 mDisplayHeight, mPixelFormat, mDataspace);
277 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
278 std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);
279 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
280 {0, 0, mDisplayWidth, mDisplayHeight / 4}, RED);
281 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
282 {0, mDisplayHeight / 4, mDisplayWidth, mDisplayHeight / 2},
283 GREEN);
284 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
285 {0, mDisplayHeight / 2, mDisplayWidth, mDisplayHeight},
286 BLUE);
287
288 auto layer = std::make_shared<TestBufferLayer>(
289 mComposerClient, mGralloc, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,
290 mDisplayHeight, PixelFormat::RGBA_8888);
291 layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});
292 layer->setZOrder(10);
293 layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
294 ASSERT_NO_FATAL_FAILURE(layer->setBuffer(expectedColors));
295
296 std::vector<std::shared_ptr<TestLayer>> layers = {layer};
297
298 writeLayers(layers);
299 ASSERT_EQ(0, mReader->mErrors.size());
300 mWriter->validateDisplay();
301 execute();
302
303 if (mReader->mCompositionChanges.size() != 0) {
304 clearCommandReaderState();
305 GTEST_SUCCEED();
306 return;
307 }
308 ASSERT_EQ(0, mReader->mErrors.size());
309
310 mWriter->presentDisplay();
311 execute();
312
313 ASSERT_EQ(0, mReader->mErrors.size());
314
315 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
316 mTestRenderEngine->setRenderLayers(layers);
317 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
318 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
319 }
320 }
321
TEST_P(GraphicsCompositionTest,SetLayerBufferNoEffect)322 TEST_P(GraphicsCompositionTest, SetLayerBufferNoEffect) {
323 for (ColorMode mode : mTestColorModes) {
324 std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"
325 << std::endl;
326 mWriter->selectDisplay(mPrimaryDisplay);
327 ASSERT_NO_FATAL_FAILURE(
328 mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
329
330 mComposerClient->getRaw()->getReadbackBufferAttributes(
331 mPrimaryDisplay,
332 [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {
333 mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,
334 tmpDataspace, tmpError);
335 mPixelFormat = tmpPixelFormat;
336 mDataspace = tmpDataspace;
337 });
338
339 if (!mHasReadbackBuffer) {
340 std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;
341 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
342 return;
343 }
344
345 auto layer = std::make_shared<TestColorLayer>(mComposerClient, mPrimaryDisplay);
346 IComposerClient::Rect coloredSquare({0, 0, mDisplayWidth, mDisplayHeight});
347 layer->setColor(BLUE);
348 layer->setDisplayFrame(coloredSquare);
349 layer->setZOrder(10);
350 layer->write(mWriter);
351
352 // This following buffer call should have no effect
353 uint64_t usage =
354 static_cast<uint64_t>(BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN);
355 NativeHandleWrapper bufferHandle =
356 mGralloc->allocate(mDisplayWidth, mDisplayHeight, 1, PixelFormat::RGBA_8888, usage);
357 mWriter->setLayerBuffer(0, bufferHandle.get(), -1);
358
359 // expected color for each pixel
360 std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);
361 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, coloredSquare, BLUE);
362
363 ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth,
364 mDisplayHeight, mPixelFormat, mDataspace);
365 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
366
367 mWriter->validateDisplay();
368 execute();
369
370 if (mReader->mCompositionChanges.size() != 0) {
371 clearCommandReaderState();
372 GTEST_SUCCEED();
373 return;
374 }
375 ASSERT_EQ(0, mReader->mErrors.size());
376 mWriter->presentDisplay();
377 execute();
378 ASSERT_EQ(0, mReader->mErrors.size());
379
380 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
381 }
382 }
383
TEST_P(GraphicsCompositionTest,ClientComposition)384 TEST_P(GraphicsCompositionTest, ClientComposition) {
385 ASSERT_NO_FATAL_FAILURE(
386 mComposerClient->setClientTargetSlotCount(mPrimaryDisplay, kClientTargetSlotCount));
387
388 for (ColorMode mode : mTestColorModes) {
389 std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"
390 << std::endl;
391 mWriter->selectDisplay(mPrimaryDisplay);
392 ASSERT_NO_FATAL_FAILURE(
393 mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
394
395 mComposerClient->getRaw()->getReadbackBufferAttributes(
396 mPrimaryDisplay,
397 [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {
398 mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,
399 tmpDataspace, tmpError);
400 mPixelFormat = tmpPixelFormat;
401 mDataspace = tmpDataspace;
402 });
403
404 if (!mHasReadbackBuffer) {
405 std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;
406 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
407 return;
408 }
409
410 mWriter->selectDisplay(mPrimaryDisplay);
411
412 std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);
413 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
414 {0, 0, mDisplayWidth, mDisplayHeight / 4}, RED);
415 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
416 {0, mDisplayHeight / 4, mDisplayWidth, mDisplayHeight / 2},
417 GREEN);
418 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
419 {0, mDisplayHeight / 2, mDisplayWidth, mDisplayHeight},
420 BLUE);
421
422 auto layer = std::make_shared<TestBufferLayer>(
423 mComposerClient, mGralloc, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,
424 mDisplayHeight, PixelFormat::RGBA_FP16);
425 layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});
426 layer->setZOrder(10);
427 layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
428
429 std::vector<std::shared_ptr<TestLayer>> layers = {layer};
430
431 ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth,
432 mDisplayHeight, mPixelFormat, mDataspace);
433 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
434 writeLayers(layers);
435 ASSERT_EQ(0, mReader->mErrors.size());
436 mWriter->validateDisplay();
437 execute();
438
439 if (mReader->mCompositionChanges.size() != 0) {
440 ASSERT_EQ(1, mReader->mCompositionChanges.size());
441 ASSERT_EQ(1, mReader->mCompositionChanges[0].second);
442
443 PixelFormat clientFormat = PixelFormat::RGBA_8888;
444 uint64_t clientUsage = static_cast<uint64_t>(BufferUsage::CPU_READ_OFTEN |
445 BufferUsage::CPU_WRITE_OFTEN |
446 BufferUsage::COMPOSER_CLIENT_TARGET);
447 Dataspace clientDataspace = ReadbackHelper::getDataspaceForColorMode(mode);
448 IComposerClient::Rect damage{0, 0, mDisplayWidth, mDisplayHeight};
449
450 bool clientTargetSupported = mComposerClient->getClientTargetSupport_2_2(
451 mPrimaryDisplay, layer->mWidth, layer->mHeight, clientFormat, clientDataspace);
452 // if the client target format is not supported, skip this
453 // configuration
454 if (!clientTargetSupported) {
455 std::cout << "Client target configuration width: " << layer->mWidth
456 << " height: " << layer->mHeight
457 << " pixel format: PixelFormat::RGBA_8888 dataspace: "
458 << ReadbackHelper::getDataspaceString(clientDataspace)
459 << " unsupported for display" << std::endl;
460 mReader->mCompositionChanges.clear();
461 continue;
462 }
463
464 // create client target buffer
465 uint32_t clientStride;
466 NativeHandleWrapper clientBufferHandle =
467 mGralloc->allocate(layer->mWidth, layer->mHeight, layer->mLayerCount,
468 clientFormat, clientUsage, /*import*/ true, &clientStride);
469 ASSERT_NE(nullptr, clientBufferHandle.get());
470
471 void* clientBufData =
472 mGralloc->lock(clientBufferHandle.get(), clientUsage, layer->mAccessRegion, -1);
473
474 ASSERT_NO_FATAL_FAILURE(ReadbackHelper::fillBuffer(layer->mWidth, layer->mHeight,
475 clientStride, clientBufData,
476 clientFormat, expectedColors));
477 int clientFence = mGralloc->unlock(clientBufferHandle.get());
478 if (clientFence != -1) {
479 sync_wait(clientFence, -1);
480 close(clientFence);
481 }
482
483 mWriter->setClientTarget(0, clientBufferHandle.get(), clientFence, clientDataspace,
484 std::vector<IComposerClient::Rect>(1, damage));
485
486 layer->setToClientComposition(mWriter);
487 mWriter->validateDisplay();
488 execute();
489 ASSERT_EQ(0, mReader->mCompositionChanges.size());
490 }
491 ASSERT_EQ(0, mReader->mErrors.size());
492
493 mWriter->presentDisplay();
494 execute();
495
496 ASSERT_EQ(0, mReader->mErrors.size());
497
498 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
499 }
500 }
501
TEST_P(GraphicsCompositionTest,DeviceAndClientComposition)502 TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) {
503 ASSERT_NO_FATAL_FAILURE(
504 mComposerClient->setClientTargetSlotCount(mPrimaryDisplay, kClientTargetSlotCount));
505
506 for (ColorMode mode : mTestColorModes) {
507 std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"
508 << std::endl;
509 mWriter->selectDisplay(mPrimaryDisplay);
510 ASSERT_NO_FATAL_FAILURE(
511 mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
512
513 mComposerClient->getRaw()->getReadbackBufferAttributes(
514 mPrimaryDisplay,
515 [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {
516 mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,
517 tmpDataspace, tmpError);
518 mPixelFormat = tmpPixelFormat;
519 mDataspace = tmpDataspace;
520 });
521
522 if (!mHasReadbackBuffer) {
523 std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;
524 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
525 return;
526 }
527
528 std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);
529 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
530 {0, 0, mDisplayWidth, mDisplayHeight / 2}, GREEN);
531 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
532 {0, mDisplayHeight / 2, mDisplayWidth, mDisplayHeight}, RED);
533
534 ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth,
535 mDisplayHeight, mPixelFormat, mDataspace);
536 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
537
538 auto deviceLayer = std::make_shared<TestBufferLayer>(
539 mComposerClient, mGralloc, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,
540 mDisplayHeight / 2, PixelFormat::RGBA_8888);
541 std::vector<IComposerClient::Color> deviceColors(deviceLayer->mWidth *
542 deviceLayer->mHeight);
543 ReadbackHelper::fillColorsArea(deviceColors, deviceLayer->mWidth,
544 {0, 0, static_cast<int32_t>(deviceLayer->mWidth),
545 static_cast<int32_t>(deviceLayer->mHeight)},
546 GREEN);
547 deviceLayer->setDisplayFrame({0, 0, static_cast<int32_t>(deviceLayer->mWidth),
548 static_cast<int32_t>(deviceLayer->mHeight)});
549 deviceLayer->setZOrder(10);
550 deviceLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
551 ASSERT_NO_FATAL_FAILURE(deviceLayer->setBuffer(deviceColors));
552 deviceLayer->write(mWriter);
553
554 PixelFormat clientFormat = PixelFormat::RGBA_8888;
555 uint64_t clientUsage =
556 static_cast<uint64_t>(BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN |
557 BufferUsage::COMPOSER_CLIENT_TARGET);
558 Dataspace clientDataspace = ReadbackHelper::getDataspaceForColorMode(mode);
559 int32_t clientWidth = mDisplayWidth;
560 int32_t clientHeight = mDisplayHeight / 2;
561
562 bool clientTargetSupported = mComposerClient->getClientTargetSupport_2_2(
563 mPrimaryDisplay, clientWidth, clientHeight, clientFormat, clientDataspace);
564 // if the client target format is not supported, skip this
565 // configuration
566 if (!clientTargetSupported) {
567 std::cout << "Client target configuration width: " << clientWidth
568 << " height: " << clientHeight
569 << " pixel format: PixelFormat::RGBA_8888 dataspace: "
570 << ReadbackHelper::getDataspaceString(clientDataspace)
571 << " unsupported for display" << std::endl;
572 continue;
573 }
574
575 auto clientLayer = std::make_shared<TestBufferLayer>(
576 mComposerClient, mGralloc, *mTestRenderEngine, mPrimaryDisplay, clientWidth,
577 clientHeight, PixelFormat::RGBA_FP16, IComposerClient::Composition::DEVICE);
578 IComposerClient::Rect clientFrame = {0, mDisplayHeight / 2, mDisplayWidth, mDisplayHeight};
579 clientLayer->setDisplayFrame(clientFrame);
580 clientLayer->setZOrder(0);
581 clientLayer->write(mWriter);
582 mWriter->validateDisplay();
583 execute();
584
585 if (mReader->mCompositionChanges.size() != 1) {
586 std::cout << "HWC asked for none or more than 1 composition change, skipping"
587 << std::endl;
588 mReader->mCompositionChanges.clear();
589 continue;
590 }
591 // create client target buffer
592 ASSERT_EQ(1, mReader->mCompositionChanges[0].second);
593 uint32_t clientStride;
594 NativeHandleWrapper clientBufferHandle =
595 mGralloc->allocate(mDisplayWidth, mDisplayHeight, clientLayer->mLayerCount,
596 clientFormat, clientUsage, /*import*/ true, &clientStride);
597 ASSERT_NE(nullptr, clientBufferHandle.get());
598
599 void* clientBufData = mGralloc->lock(clientBufferHandle.get(), clientUsage,
600 {0, 0, mDisplayWidth, mDisplayHeight}, -1);
601
602 std::vector<IComposerClient::Color> clientColors(mDisplayWidth * mDisplayHeight);
603 ReadbackHelper::fillColorsArea(clientColors, mDisplayWidth, clientFrame, RED);
604 ASSERT_NO_FATAL_FAILURE(ReadbackHelper::fillBuffer(mDisplayWidth, mDisplayHeight,
605 clientStride, clientBufData,
606 clientFormat, clientColors));
607 int clientFence = mGralloc->unlock(clientBufferHandle.get());
608 if (clientFence != -1) {
609 sync_wait(clientFence, -1);
610 close(clientFence);
611 }
612
613 mWriter->setClientTarget(0, clientBufferHandle.get(), clientFence, clientDataspace,
614 std::vector<IComposerClient::Rect>(1, clientFrame));
615 clientLayer->setToClientComposition(mWriter);
616 mWriter->validateDisplay();
617 execute();
618 ASSERT_EQ(0, mReader->mCompositionChanges.size());
619 ASSERT_EQ(0, mReader->mErrors.size());
620
621 mWriter->presentDisplay();
622 execute();
623 ASSERT_EQ(0, mReader->mErrors.size());
624 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
625 }
626 }
627
TEST_P(GraphicsCompositionTest,SetLayerDamage)628 TEST_P(GraphicsCompositionTest, SetLayerDamage) {
629 for (ColorMode mode : mTestColorModes) {
630 std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"
631 << std::endl;
632 mWriter->selectDisplay(mPrimaryDisplay);
633 ASSERT_NO_FATAL_FAILURE(
634 mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
635
636 mComposerClient->getRaw()->getReadbackBufferAttributes(
637 mPrimaryDisplay,
638 [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {
639 mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,
640 tmpDataspace, tmpError);
641 mPixelFormat = tmpPixelFormat;
642 mDataspace = tmpDataspace;
643 });
644
645 if (!mHasReadbackBuffer) {
646 std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;
647 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
648 return;
649 }
650
651 mWriter->selectDisplay(mPrimaryDisplay);
652
653 IComposerClient::Rect redRect = {0, 0, mDisplayWidth / 4, mDisplayHeight / 4};
654
655 std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);
656 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, redRect, RED);
657
658 auto layer = std::make_shared<TestBufferLayer>(
659 mComposerClient, mGralloc, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,
660 mDisplayHeight, PixelFormat::RGBA_8888);
661 layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});
662 layer->setZOrder(10);
663 layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
664 ASSERT_NO_FATAL_FAILURE(layer->setBuffer(expectedColors));
665
666 std::vector<std::shared_ptr<TestLayer>> layers = {layer};
667
668 ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth,
669 mDisplayHeight, mPixelFormat, mDataspace);
670 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
671
672 writeLayers(layers);
673 ASSERT_EQ(0, mReader->mErrors.size());
674 mWriter->validateDisplay();
675 execute();
676 if (mReader->mCompositionChanges.size() != 0) {
677 clearCommandReaderState();
678 GTEST_SUCCEED();
679 return;
680 }
681 ASSERT_EQ(0, mReader->mErrors.size());
682 mWriter->presentDisplay();
683 execute();
684 ASSERT_EQ(0, mReader->mErrors.size());
685
686 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
687
688 // update surface damage and recheck
689 redRect = {mDisplayWidth / 4, mDisplayHeight / 4, mDisplayWidth / 2, mDisplayHeight / 2};
690 ReadbackHelper::clearColors(expectedColors, mDisplayWidth, mDisplayHeight, mDisplayWidth);
691 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, redRect, RED);
692
693 ASSERT_NO_FATAL_FAILURE(layer->fillBuffer(expectedColors));
694 layer->setSurfaceDamage(std::vector<IComposerClient::Rect>(
695 1, {0, 0, mDisplayWidth / 2, mDisplayWidth / 2}));
696
697 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
698
699 writeLayers(layers);
700 ASSERT_EQ(0, mReader->mErrors.size());
701 mWriter->validateDisplay();
702 execute();
703 ASSERT_EQ(0, mReader->mErrors.size());
704 ASSERT_EQ(0, mReader->mCompositionChanges.size());
705 mWriter->presentDisplay();
706 execute();
707 ASSERT_EQ(0, mReader->mErrors.size());
708
709 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
710 }
711 }
712
TEST_P(GraphicsCompositionTest,SetLayerPlaneAlpha)713 TEST_P(GraphicsCompositionTest, SetLayerPlaneAlpha) {
714 for (ColorMode mode : mTestColorModes) {
715 std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"
716 << std::endl;
717 mWriter->selectDisplay(mPrimaryDisplay);
718 ASSERT_NO_FATAL_FAILURE(
719 mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
720
721 mComposerClient->getRaw()->getReadbackBufferAttributes(
722 mPrimaryDisplay,
723 [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {
724 mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,
725 tmpDataspace, tmpError);
726 mPixelFormat = tmpPixelFormat;
727 mDataspace = tmpDataspace;
728 });
729
730 if (!mHasReadbackBuffer) {
731 std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;
732 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
733 return;
734 }
735
736 auto layer = std::make_shared<TestColorLayer>(mComposerClient, mPrimaryDisplay);
737 layer->setColor(RED);
738 layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});
739 layer->setZOrder(10);
740 layer->setAlpha(0);
741 layer->setBlendMode(IComposerClient::BlendMode::PREMULTIPLIED);
742
743 std::vector<std::shared_ptr<TestLayer>> layers = {layer};
744
745 ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth,
746 mDisplayHeight, mPixelFormat, mDataspace);
747
748 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
749
750 writeLayers(layers);
751 ASSERT_EQ(0, mReader->mErrors.size());
752 mWriter->validateDisplay();
753 execute();
754 if (mReader->mCompositionChanges.size() != 0) {
755 clearCommandReaderState();
756 GTEST_SUCCEED();
757 return;
758 }
759 ASSERT_EQ(0, mReader->mErrors.size());
760
761 mWriter->presentDisplay();
762 execute();
763 ASSERT_EQ(0, mReader->mErrors.size());
764
765 std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);
766
767 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
768 mTestRenderEngine->setRenderLayers(layers);
769 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
770 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
771 }
772 }
773
TEST_P(GraphicsCompositionTest,SetLayerSourceCrop)774 TEST_P(GraphicsCompositionTest, SetLayerSourceCrop) {
775 for (ColorMode mode : mTestColorModes) {
776 std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"
777 << std::endl;
778 mWriter->selectDisplay(mPrimaryDisplay);
779 ASSERT_NO_FATAL_FAILURE(
780 mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
781
782 mComposerClient->getRaw()->getReadbackBufferAttributes(
783 mPrimaryDisplay,
784 [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {
785 mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,
786 tmpDataspace, tmpError);
787 mPixelFormat = tmpPixelFormat;
788 mDataspace = tmpDataspace;
789 });
790
791 if (!mHasReadbackBuffer) {
792 std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;
793 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
794 return;
795 }
796
797 mWriter->selectDisplay(mPrimaryDisplay);
798
799 std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);
800 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
801 {0, 0, mDisplayWidth, mDisplayHeight / 4}, RED);
802 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
803 {0, mDisplayHeight / 2, mDisplayWidth, mDisplayHeight},
804 BLUE);
805
806 auto layer = std::make_shared<TestBufferLayer>(
807 mComposerClient, mGralloc, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,
808 mDisplayHeight, PixelFormat::RGBA_8888);
809 layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});
810 layer->setZOrder(10);
811 layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
812 layer->setSourceCrop({0, static_cast<float>(mDisplayHeight / 2),
813 static_cast<float>(mDisplayWidth),
814 static_cast<float>(mDisplayHeight)});
815 ASSERT_NO_FATAL_FAILURE(layer->setBuffer(expectedColors));
816
817 std::vector<std::shared_ptr<TestLayer>> layers = {layer};
818
819 // update expected colors to match crop
820 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
821 {0, 0, mDisplayWidth, mDisplayHeight}, BLUE);
822 ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth,
823 mDisplayHeight, mPixelFormat, mDataspace);
824 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
825 writeLayers(layers);
826 ASSERT_EQ(0, mReader->mErrors.size());
827 mWriter->validateDisplay();
828 execute();
829 if (mReader->mCompositionChanges.size() != 0) {
830 clearCommandReaderState();
831 GTEST_SUCCEED();
832 return;
833 }
834 ASSERT_EQ(0, mReader->mErrors.size());
835 mWriter->presentDisplay();
836 execute();
837 ASSERT_EQ(0, mReader->mErrors.size());
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,SetLayerZOrder)845 TEST_P(GraphicsCompositionTest, SetLayerZOrder) {
846 for (ColorMode mode : mTestColorModes) {
847 std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"
848 << std::endl;
849 mWriter->selectDisplay(mPrimaryDisplay);
850 ASSERT_NO_FATAL_FAILURE(
851 mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
852
853 mComposerClient->getRaw()->getReadbackBufferAttributes(
854 mPrimaryDisplay,
855 [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {
856 mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,
857 tmpDataspace, tmpError);
858 mPixelFormat = tmpPixelFormat;
859 mDataspace = tmpDataspace;
860 });
861
862 if (!mHasReadbackBuffer) {
863 std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;
864 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
865 return;
866 }
867
868 IComposerClient::Rect redRect = {0, 0, mDisplayWidth, mDisplayHeight / 2};
869 IComposerClient::Rect blueRect = {0, mDisplayHeight / 4, mDisplayWidth, mDisplayHeight};
870 auto redLayer = std::make_shared<TestColorLayer>(mComposerClient, mPrimaryDisplay);
871 redLayer->setColor(RED);
872 redLayer->setDisplayFrame(redRect);
873
874 auto blueLayer = std::make_shared<TestColorLayer>(mComposerClient, mPrimaryDisplay);
875 blueLayer->setColor(BLUE);
876 blueLayer->setDisplayFrame(blueRect);
877 blueLayer->setZOrder(5);
878
879 std::vector<std::shared_ptr<TestLayer>> layers = {redLayer, blueLayer};
880 std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);
881
882 // red in front of blue
883 redLayer->setZOrder(10);
884
885 // fill blue first so that red will overwrite on overlap
886 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, blueRect, BLUE);
887 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, redRect, RED);
888
889 ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth,
890 mDisplayHeight, mPixelFormat, mDataspace);
891 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
892
893 writeLayers(layers);
894 ASSERT_EQ(0, mReader->mErrors.size());
895 mWriter->validateDisplay();
896 execute();
897 if (mReader->mCompositionChanges.size() != 0) {
898 clearCommandReaderState();
899 GTEST_SUCCEED();
900 return;
901 }
902 mWriter->presentDisplay();
903 execute();
904 ASSERT_EQ(0, mReader->mErrors.size());
905
906 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
907
908 redLayer->setZOrder(1);
909 ReadbackHelper::clearColors(expectedColors, mDisplayWidth, mDisplayHeight, mDisplayWidth);
910 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, redRect, RED);
911 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth, blueRect, BLUE);
912
913 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
914
915 writeLayers(layers);
916 ASSERT_EQ(0, mReader->mErrors.size());
917 mWriter->validateDisplay();
918 execute();
919 ASSERT_EQ(0, mReader->mCompositionChanges.size());
920 ASSERT_EQ(0, mReader->mErrors.size());
921 mWriter->presentDisplay();
922 execute();
923 ASSERT_EQ(0, mReader->mErrors.size());
924
925 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
926 mTestRenderEngine->setRenderLayers(layers);
927 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
928 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
929 }
930 }
931
932 class GraphicsBlendModeCompositionTest
933 : public GraphicsCompositionTestBase,
934 public testing::WithParamInterface<std::tuple<std::string, std::string>> {
935 public:
SetUp()936 void SetUp() override {
937 SetUpBase(std::get<0>(GetParam()));
938 mTestColorModes = {ColorMode::SRGB}; // TODO: add more color mode support
939 mBackgroundColor = BLACK;
940 mTopLayerColor = RED;
941 }
942
setBackgroundColor(IComposerClient::Color color)943 void setBackgroundColor(IComposerClient::Color color) { mBackgroundColor = color; }
944
setTopLayerColor(IComposerClient::Color color)945 void setTopLayerColor(IComposerClient::Color color) { mTopLayerColor = color; }
946
setUpLayers(IComposerClient::BlendMode blendMode)947 void setUpLayers(IComposerClient::BlendMode blendMode) {
948 mLayers.clear();
949 std::vector<IComposerClient::Color> topLayerPixelColors(mDisplayWidth * mDisplayHeight);
950 ReadbackHelper::fillColorsArea(topLayerPixelColors, mDisplayWidth,
951 {0, 0, mDisplayWidth, mDisplayHeight}, mTopLayerColor);
952
953 auto backgroundLayer = std::make_shared<TestColorLayer>(mComposerClient, mPrimaryDisplay);
954 backgroundLayer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});
955 backgroundLayer->setZOrder(0);
956 backgroundLayer->setColor(mBackgroundColor);
957
958 auto layer = std::make_shared<TestBufferLayer>(
959 mComposerClient, mGralloc, *mTestRenderEngine, mPrimaryDisplay, mDisplayWidth,
960 mDisplayHeight, PixelFormat::RGBA_8888);
961 layer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});
962 layer->setZOrder(10);
963 layer->setDataspace(Dataspace::UNKNOWN, mWriter);
964 ASSERT_NO_FATAL_FAILURE(layer->setBuffer(topLayerPixelColors));
965
966 layer->setBlendMode(blendMode);
967 layer->setAlpha(std::stof(std::get<1>(GetParam())));
968
969 mLayers.push_back(backgroundLayer);
970 mLayers.push_back(layer);
971 }
972
setExpectedColors(std::vector<IComposerClient::Color> & expectedColors)973 void setExpectedColors(std::vector<IComposerClient::Color>& expectedColors) {
974 ASSERT_EQ(2, mLayers.size());
975 ReadbackHelper::clearColors(expectedColors, mDisplayWidth, mDisplayHeight, mDisplayWidth);
976
977 auto layer = mLayers[1];
978 IComposerClient::BlendMode blendMode = layer->mBlendMode;
979 float alpha = mTopLayerColor.a / 255.0 * layer->mAlpha;
980 if (blendMode == IComposerClient::BlendMode::NONE) {
981 for (int i = 0; i < expectedColors.size(); i++) {
982 expectedColors[i].r = mTopLayerColor.r * layer->mAlpha;
983 expectedColors[i].g = mTopLayerColor.g * layer->mAlpha;
984 expectedColors[i].b = mTopLayerColor.b * layer->mAlpha;
985 expectedColors[i].a = alpha * 255.0;
986 }
987 } else if (blendMode == IComposerClient::BlendMode::PREMULTIPLIED) {
988 for (int i = 0; i < expectedColors.size(); i++) {
989 expectedColors[i].r =
990 mTopLayerColor.r * layer->mAlpha + mBackgroundColor.r * (1.0 - alpha);
991 expectedColors[i].g =
992 mTopLayerColor.g * layer->mAlpha + mBackgroundColor.g * (1.0 - alpha);
993 expectedColors[i].b =
994 mTopLayerColor.b * layer->mAlpha + mBackgroundColor.b * (1.0 - alpha);
995 expectedColors[i].a = alpha + mBackgroundColor.a * (1.0 - alpha);
996 }
997 } else if (blendMode == IComposerClient::BlendMode::COVERAGE) {
998 for (int i = 0; i < expectedColors.size(); i++) {
999 expectedColors[i].r = mTopLayerColor.r * alpha + mBackgroundColor.r * (1.0 - alpha);
1000 expectedColors[i].g = mTopLayerColor.g * alpha + mBackgroundColor.g * (1.0 - alpha);
1001 expectedColors[i].b = mTopLayerColor.b * alpha + mBackgroundColor.b * (1.0 - alpha);
1002 expectedColors[i].a = mTopLayerColor.a * alpha + mBackgroundColor.a * (1.0 - alpha);
1003 }
1004 }
1005 }
1006
1007 protected:
1008 std::vector<std::shared_ptr<TestLayer>> mLayers;
1009 IComposerClient::Color mBackgroundColor;
1010 IComposerClient::Color mTopLayerColor;
1011 };
1012
1013 // TODO(b/145557764): Re-enable after the bug is fixed.
TEST_P(GraphicsBlendModeCompositionTest,DISABLED_None)1014 TEST_P(GraphicsBlendModeCompositionTest, DISABLED_None) {
1015 for (ColorMode mode : mTestColorModes) {
1016 std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"
1017 << std::endl;
1018 mWriter->selectDisplay(mPrimaryDisplay);
1019 ASSERT_NO_FATAL_FAILURE(
1020 mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
1021
1022 mComposerClient->getRaw()->getReadbackBufferAttributes(
1023 mPrimaryDisplay,
1024 [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {
1025 mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,
1026 tmpDataspace, tmpError);
1027 mPixelFormat = tmpPixelFormat;
1028 mDataspace = tmpDataspace;
1029 });
1030
1031 if (!mHasReadbackBuffer) {
1032 std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;
1033 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
1034 return;
1035 }
1036
1037 mWriter->selectDisplay(mPrimaryDisplay);
1038
1039 std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);
1040
1041 setBackgroundColor(BLACK);
1042 setTopLayerColor(TRANSLUCENT_RED);
1043 setUpLayers(IComposerClient::BlendMode::NONE);
1044 setExpectedColors(expectedColors);
1045
1046 ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth,
1047 mDisplayHeight, mPixelFormat, mDataspace);
1048 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
1049 writeLayers(mLayers);
1050 ASSERT_EQ(0, mReader->mErrors.size());
1051 mWriter->validateDisplay();
1052 execute();
1053 if (mReader->mCompositionChanges.size() != 0) {
1054 clearCommandReaderState();
1055 GTEST_SUCCEED();
1056 return;
1057 }
1058 ASSERT_EQ(0, mReader->mErrors.size());
1059 mWriter->presentDisplay();
1060 execute();
1061 ASSERT_EQ(0, mReader->mErrors.size());
1062
1063 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
1064 mTestRenderEngine->setRenderLayers(mLayers);
1065 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
1066 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
1067 }
1068 }
1069
1070 // TODO: bug 116865056: Readback returns (245, 0, 0) for layer plane
1071 // alpha of .2, expected 10.2
TEST_P(GraphicsBlendModeCompositionTest,DISABLED_Coverage)1072 TEST_P(GraphicsBlendModeCompositionTest, DISABLED_Coverage) {
1073 for (ColorMode mode : mTestColorModes) {
1074 std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"
1075 << std::endl;
1076 mWriter->selectDisplay(mPrimaryDisplay);
1077 ASSERT_NO_FATAL_FAILURE(
1078 mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
1079
1080 mComposerClient->getRaw()->getReadbackBufferAttributes(
1081 mPrimaryDisplay,
1082 [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {
1083 mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,
1084 tmpDataspace, tmpError);
1085 mPixelFormat = tmpPixelFormat;
1086 mDataspace = tmpDataspace;
1087 });
1088
1089 if (!mHasReadbackBuffer) {
1090 std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;
1091 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
1092 return;
1093 }
1094
1095 mWriter->selectDisplay(mPrimaryDisplay);
1096
1097 std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);
1098
1099 setBackgroundColor(BLACK);
1100 setTopLayerColor(TRANSLUCENT_RED);
1101
1102 setUpLayers(IComposerClient::BlendMode::COVERAGE);
1103 setExpectedColors(expectedColors);
1104
1105 ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth,
1106 mDisplayHeight, mPixelFormat, mDataspace);
1107 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
1108 writeLayers(mLayers);
1109 ASSERT_EQ(0, mReader->mErrors.size());
1110 mWriter->validateDisplay();
1111 execute();
1112 if (mReader->mCompositionChanges.size() != 0) {
1113 clearCommandReaderState();
1114 GTEST_SUCCEED();
1115 return;
1116 }
1117 ASSERT_EQ(0, mReader->mErrors.size());
1118 mWriter->presentDisplay();
1119 execute();
1120 ASSERT_EQ(0, mReader->mErrors.size());
1121 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
1122 }
1123 }
1124
TEST_P(GraphicsBlendModeCompositionTest,Premultiplied)1125 TEST_P(GraphicsBlendModeCompositionTest, Premultiplied) {
1126 for (ColorMode mode : mTestColorModes) {
1127 std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"
1128 << std::endl;
1129 mWriter->selectDisplay(mPrimaryDisplay);
1130 ASSERT_NO_FATAL_FAILURE(
1131 mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
1132
1133 mComposerClient->getRaw()->getReadbackBufferAttributes(
1134 mPrimaryDisplay,
1135 [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {
1136 mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,
1137 tmpDataspace, tmpError);
1138 mPixelFormat = tmpPixelFormat;
1139 mDataspace = tmpDataspace;
1140 });
1141
1142 if (!mHasReadbackBuffer) {
1143 std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;
1144 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
1145 return;
1146 }
1147 mWriter->selectDisplay(mPrimaryDisplay);
1148
1149 std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);
1150
1151 setBackgroundColor(BLACK);
1152 setTopLayerColor(TRANSLUCENT_RED);
1153 setUpLayers(IComposerClient::BlendMode::PREMULTIPLIED);
1154 setExpectedColors(expectedColors);
1155
1156 ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth,
1157 mDisplayHeight, mPixelFormat, mDataspace);
1158 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
1159 writeLayers(mLayers);
1160 ASSERT_EQ(0, mReader->mErrors.size());
1161 mWriter->validateDisplay();
1162 execute();
1163 if (mReader->mCompositionChanges.size() != 0) {
1164 clearCommandReaderState();
1165 GTEST_SUCCEED();
1166 return;
1167 }
1168 ASSERT_EQ(0, mReader->mErrors.size());
1169 mWriter->presentDisplay();
1170 execute();
1171 ASSERT_EQ(0, mReader->mErrors.size());
1172 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
1173 mTestRenderEngine->setRenderLayers(mLayers);
1174 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
1175 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
1176 }
1177 }
1178
1179 class GraphicsTransformCompositionTest : public GraphicsCompositionTest {
1180 protected:
SetUp()1181 void SetUp() override {
1182 GraphicsCompositionTest::SetUp();
1183
1184 mWriter->selectDisplay(mPrimaryDisplay);
1185
1186 auto backgroundLayer = std::make_shared<TestColorLayer>(mComposerClient, mPrimaryDisplay);
1187 backgroundLayer->setColor({0, 0, 0, 0});
1188 backgroundLayer->setDisplayFrame({0, 0, mDisplayWidth, mDisplayHeight});
1189 backgroundLayer->setZOrder(0);
1190
1191 mSideLength = mDisplayWidth < mDisplayHeight ? mDisplayWidth : mDisplayHeight;
1192 IComposerClient::Rect redRect = {0, 0, mSideLength / 2, mSideLength / 2};
1193 IComposerClient::Rect blueRect = {mSideLength / 2, mSideLength / 2, mSideLength,
1194 mSideLength};
1195
1196 mLayer = std::make_shared<TestBufferLayer>(mComposerClient, mGralloc, *mTestRenderEngine,
1197 mPrimaryDisplay, mSideLength, mSideLength,
1198 PixelFormat::RGBA_8888);
1199 mLayer->setDisplayFrame({0, 0, mSideLength, mSideLength});
1200 mLayer->setZOrder(10);
1201
1202 std::vector<IComposerClient::Color> baseColors(mSideLength * mSideLength);
1203 ReadbackHelper::fillColorsArea(baseColors, mSideLength, redRect, RED);
1204 ReadbackHelper::fillColorsArea(baseColors, mSideLength, blueRect, BLUE);
1205 ASSERT_NO_FATAL_FAILURE(mLayer->setBuffer(baseColors));
1206
1207 mLayers = {backgroundLayer, mLayer};
1208 }
1209
1210 protected:
1211 std::shared_ptr<TestBufferLayer> mLayer;
1212 std::vector<IComposerClient::Color> baseColors;
1213 std::vector<std::shared_ptr<TestLayer>> mLayers;
1214 int mSideLength;
1215 };
1216
TEST_P(GraphicsTransformCompositionTest,FLIP_H)1217 TEST_P(GraphicsTransformCompositionTest, FLIP_H) {
1218 for (ColorMode mode : mTestColorModes) {
1219 std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"
1220 << std::endl;
1221 mWriter->selectDisplay(mPrimaryDisplay);
1222 ASSERT_NO_FATAL_FAILURE(
1223 mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
1224
1225 mComposerClient->getRaw()->getReadbackBufferAttributes(
1226 mPrimaryDisplay,
1227 [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {
1228 mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,
1229 tmpDataspace, tmpError);
1230 mPixelFormat = tmpPixelFormat;
1231 mDataspace = tmpDataspace;
1232 });
1233
1234 if (!mHasReadbackBuffer) {
1235 std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;
1236 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
1237 return;
1238 }
1239 ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth,
1240 mDisplayHeight, mPixelFormat, mDataspace);
1241 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
1242 mLayer->setTransform(Transform::FLIP_H);
1243 mLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
1244
1245 std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);
1246 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
1247 {mSideLength / 2, 0, mSideLength, mSideLength / 2}, RED);
1248 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
1249 {0, mSideLength / 2, mSideLength / 2, mSideLength}, BLUE);
1250
1251 writeLayers(mLayers);
1252 ASSERT_EQ(0, mReader->mErrors.size());
1253 mWriter->validateDisplay();
1254 execute();
1255 if (mReader->mCompositionChanges.size() != 0) {
1256 clearCommandReaderState();
1257 GTEST_SUCCEED();
1258 return;
1259 }
1260 ASSERT_EQ(0, mReader->mErrors.size());
1261 mWriter->presentDisplay();
1262 execute();
1263 ASSERT_EQ(0, mReader->mErrors.size());
1264
1265 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
1266 mTestRenderEngine->setRenderLayers(mLayers);
1267 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
1268 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
1269 }
1270 }
1271
TEST_P(GraphicsTransformCompositionTest,FLIP_V)1272 TEST_P(GraphicsTransformCompositionTest, FLIP_V) {
1273 for (ColorMode mode : mTestColorModes) {
1274 std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"
1275 << std::endl;
1276 mWriter->selectDisplay(mPrimaryDisplay);
1277 ASSERT_NO_FATAL_FAILURE(
1278 mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
1279
1280 mComposerClient->getRaw()->getReadbackBufferAttributes(
1281 mPrimaryDisplay,
1282 [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {
1283 mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,
1284 tmpDataspace, tmpError);
1285 mPixelFormat = tmpPixelFormat;
1286 mDataspace = tmpDataspace;
1287 });
1288
1289 if (!mHasReadbackBuffer) {
1290 std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;
1291 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
1292 return;
1293 }
1294 ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth,
1295 mDisplayHeight, mPixelFormat, mDataspace);
1296 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
1297
1298 mLayer->setTransform(Transform::FLIP_V);
1299 mLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
1300
1301 std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);
1302 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
1303 {0, mSideLength / 2, mSideLength / 2, mSideLength}, RED);
1304 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
1305 {mSideLength / 2, 0, mSideLength, mSideLength / 2}, BLUE);
1306
1307 writeLayers(mLayers);
1308 ASSERT_EQ(0, mReader->mErrors.size());
1309 mWriter->validateDisplay();
1310 execute();
1311 if (mReader->mCompositionChanges.size() != 0) {
1312 clearCommandReaderState();
1313 GTEST_SUCCEED();
1314 return;
1315 }
1316 ASSERT_EQ(0, mReader->mErrors.size());
1317 mWriter->presentDisplay();
1318 execute();
1319 ASSERT_EQ(0, mReader->mErrors.size());
1320 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
1321 mTestRenderEngine->setRenderLayers(mLayers);
1322 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
1323 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
1324 }
1325 }
1326
TEST_P(GraphicsTransformCompositionTest,ROT_180)1327 TEST_P(GraphicsTransformCompositionTest, ROT_180) {
1328 for (ColorMode mode : mTestColorModes) {
1329 std::cout << "---Testing Color Mode " << ReadbackHelper::getColorModeString(mode) << "---"
1330 << std::endl;
1331 mWriter->selectDisplay(mPrimaryDisplay);
1332 ASSERT_NO_FATAL_FAILURE(
1333 mComposerClient->setColorMode(mPrimaryDisplay, mode, RenderIntent::COLORIMETRIC));
1334
1335 mComposerClient->getRaw()->getReadbackBufferAttributes(
1336 mPrimaryDisplay,
1337 [&](const auto& tmpError, const auto& tmpPixelFormat, const auto& tmpDataspace) {
1338 mHasReadbackBuffer = ReadbackHelper::readbackSupported(tmpPixelFormat,
1339 tmpDataspace, tmpError);
1340 mPixelFormat = tmpPixelFormat;
1341 mDataspace = tmpDataspace;
1342 });
1343
1344 if (!mHasReadbackBuffer) {
1345 std::cout << "Readback not supported or unsupported pixelFormat/dataspace" << std::endl;
1346 GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
1347 return;
1348 }
1349 ReadbackBuffer readbackBuffer(mPrimaryDisplay, mComposerClient, mGralloc, mDisplayWidth,
1350 mDisplayHeight, mPixelFormat, mDataspace);
1351 ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
1352
1353 mLayer->setTransform(Transform::ROT_180);
1354 mLayer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode), mWriter);
1355
1356 std::vector<IComposerClient::Color> expectedColors(mDisplayWidth * mDisplayHeight);
1357 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
1358 {mSideLength / 2, mSideLength / 2, mSideLength, mSideLength},
1359 RED);
1360 ReadbackHelper::fillColorsArea(expectedColors, mDisplayWidth,
1361 {0, 0, mSideLength / 2, mSideLength / 2}, BLUE);
1362
1363 writeLayers(mLayers);
1364 ASSERT_EQ(0, mReader->mErrors.size());
1365 mWriter->validateDisplay();
1366 execute();
1367 if (mReader->mCompositionChanges.size() != 0) {
1368 clearCommandReaderState();
1369 GTEST_SUCCEED();
1370 return;
1371 }
1372 ASSERT_EQ(0, mReader->mErrors.size());
1373 mWriter->presentDisplay();
1374 execute();
1375 ASSERT_EQ(0, mReader->mErrors.size());
1376 ASSERT_NO_FATAL_FAILURE(readbackBuffer.checkReadbackBuffer(expectedColors));
1377 mTestRenderEngine->setRenderLayers(mLayers);
1378 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->drawLayers());
1379 ASSERT_NO_FATAL_FAILURE(mTestRenderEngine->checkColorBuffer(expectedColors));
1380 }
1381 }
1382
1383 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsCompositionTest);
1384 INSTANTIATE_TEST_SUITE_P(
1385 PerInstance, GraphicsCompositionTest,
1386 testing::ValuesIn(android::hardware::getAllHalInstanceNames(IComposer::descriptor)),
1387 android::hardware::PrintInstanceNameToString);
1388
1389 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsBlendModeCompositionTest);
1390 INSTANTIATE_TEST_CASE_P(
1391 BlendModeTest, GraphicsBlendModeCompositionTest,
1392 testing::Combine(
1393 testing::ValuesIn(android::hardware::getAllHalInstanceNames(IComposer::descriptor)),
1394 testing::Values("0.2", "1.0")),
1395 android::hardware::PrintInstanceTupleNameToString<>);
1396
1397 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GraphicsTransformCompositionTest);
1398 INSTANTIATE_TEST_SUITE_P(
1399 PerInstance, GraphicsTransformCompositionTest,
1400 testing::ValuesIn(android::hardware::getAllHalInstanceNames(IComposer::descriptor)),
1401 android::hardware::PrintInstanceNameToString);
1402
1403 } // anonymous namespace
1404 } // namespace vts
1405 } // namespace V2_2
1406 } // namespace composer
1407 } // namespace graphics
1408 } // namespace hardware
1409 } // namespace android
1410