blob: c72ec6974fc9597b15c2e54d2bf8ef61593f1eef [file] [log] [blame]
ramindanibab8ba92021-11-18 01:24:11 +00001/**
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
ramindani458e53e2022-02-23 17:30:16 +000017#include "ReadbackVts.h"
ramindanibab8ba92021-11-18 01:24:11 +000018#include <aidl/android/hardware/graphics/common/BufferUsage.h>
ramindani458e53e2022-02-23 17:30:16 +000019#include "RenderEngineVts.h"
ramindanibab8ba92021-11-18 01:24:11 +000020#include "renderengine/ExternalTexture.h"
Vishnu Nair59329712022-01-13 07:59:37 -080021#include "renderengine/impl/ExternalTexture.h"
ramindanibab8ba92021-11-18 01:24:11 +000022
ramindanibab8ba92021-11-18 01:24:11 +000023namespace aidl::android::hardware::graphics::composer3::vts {
24
25const std::vector<ColorMode> ReadbackHelper::colorModes = {ColorMode::SRGB, ColorMode::DISPLAY_P3};
26const std::vector<Dataspace> ReadbackHelper::dataspaces = {common::Dataspace::SRGB,
27 common::Dataspace::DISPLAY_P3};
28
Ady Abraham91c9d1a2021-12-15 18:14:45 -080029void TestLayer::write(ComposerClientWriter& writer) {
Ady Abraham3192f3d2021-12-03 16:08:56 -080030 writer.setLayerDisplayFrame(mDisplay, mLayer, mDisplayFrame);
31 writer.setLayerSourceCrop(mDisplay, mLayer, mSourceCrop);
32 writer.setLayerZOrder(mDisplay, mLayer, mZOrder);
33 writer.setLayerSurfaceDamage(mDisplay, mLayer, mSurfaceDamage);
34 writer.setLayerTransform(mDisplay, mLayer, mTransform);
35 writer.setLayerPlaneAlpha(mDisplay, mLayer, mAlpha);
36 writer.setLayerBlendMode(mDisplay, mLayer, mBlendMode);
Alec Mourib1f16722022-02-07 13:03:44 -080037 writer.setLayerBrightness(mDisplay, mLayer, mBrightness);
Alec Mourif6c039a2023-10-06 23:02:17 +000038 writer.setLayerDataspace(mDisplay, mLayer, mDataspace);
ramindanibab8ba92021-11-18 01:24:11 +000039}
40
41std::string ReadbackHelper::getColorModeString(ColorMode mode) {
42 switch (mode) {
43 case ColorMode::SRGB:
44 return {"SRGB"};
45 case ColorMode::DISPLAY_P3:
46 return {"DISPLAY_P3"};
47 default:
48 return {"Unsupported color mode for readback"};
49 }
50}
51
52std::string ReadbackHelper::getDataspaceString(common::Dataspace dataspace) {
53 switch (dataspace) {
54 case common::Dataspace::SRGB:
55 return {"SRGB"};
56 case common::Dataspace::DISPLAY_P3:
57 return {"DISPLAY_P3"};
58 case common::Dataspace::UNKNOWN:
59 return {"UNKNOWN"};
60 default:
61 return {"Unsupported dataspace for readback"};
62 }
63}
64
65Dataspace ReadbackHelper::getDataspaceForColorMode(ColorMode mode) {
66 switch (mode) {
67 case ColorMode::DISPLAY_P3:
68 return Dataspace::DISPLAY_P3;
69 case ColorMode::SRGB:
70 default:
71 return common::Dataspace::UNKNOWN;
72 }
73}
74
75LayerSettings TestLayer::toRenderEngineLayerSettings() {
76 LayerSettings layerSettings;
77
78 layerSettings.alpha = ::android::half(mAlpha);
79 layerSettings.disableBlending = mBlendMode == BlendMode::NONE;
ramindanic7585d92022-04-15 18:30:41 +000080 layerSettings.source.buffer.isOpaque = mBlendMode == BlendMode::NONE;
ramindanibab8ba92021-11-18 01:24:11 +000081 layerSettings.geometry.boundaries = ::android::FloatRect(
82 static_cast<float>(mDisplayFrame.left), static_cast<float>(mDisplayFrame.top),
83 static_cast<float>(mDisplayFrame.right), static_cast<float>(mDisplayFrame.bottom));
84
85 const ::android::mat4 translation = ::android::mat4::translate(::android::vec4(
86 (static_cast<uint64_t>(mTransform) & static_cast<uint64_t>(Transform::FLIP_H)
87 ? static_cast<float>(-mDisplayFrame.right)
88 : 0.0f),
89 (static_cast<uint64_t>(mTransform) & static_cast<uint64_t>(Transform::FLIP_V)
90 ? static_cast<float>(-mDisplayFrame.bottom)
91 : 0.0f),
92 0.0f, 1.0f));
93
94 const ::android::mat4 scale = ::android::mat4::scale(::android::vec4(
95 static_cast<uint64_t>(mTransform) & static_cast<uint64_t>(Transform::FLIP_H) ? -1.0f
96 : 1.0f,
97 static_cast<uint64_t>(mTransform) & static_cast<uint64_t>(Transform::FLIP_V) ? -1.0f
98 : 1.0f,
99 1.0f, 1.0f));
100
101 layerSettings.geometry.positionTransform = scale * translation;
Alec Mouri51067012022-01-06 17:28:39 -0800102 layerSettings.whitePointNits = mWhitePointNits;
Alec Mourif6c039a2023-10-06 23:02:17 +0000103 layerSettings.sourceDataspace = static_cast<::android::ui::Dataspace>(mDataspace);
ramindanibab8ba92021-11-18 01:24:11 +0000104
105 return layerSettings;
106}
107
Brian Lindahle887a252023-01-17 14:54:19 -0700108int32_t ReadbackHelper::GetBytesPerPixel(common::PixelFormat pixelFormat) {
ramindanibab8ba92021-11-18 01:24:11 +0000109 switch (pixelFormat) {
Brian Lindahle887a252023-01-17 14:54:19 -0700110 case common::PixelFormat::RGBA_8888:
ramindanibab8ba92021-11-18 01:24:11 +0000111 return 4;
Brian Lindahle887a252023-01-17 14:54:19 -0700112 case common::PixelFormat::RGB_888:
ramindanibab8ba92021-11-18 01:24:11 +0000113 return 3;
114 default:
115 return -1;
116 }
117}
118
119void ReadbackHelper::fillBuffer(uint32_t width, uint32_t height, uint32_t stride, void* bufferData,
120 common::PixelFormat pixelFormat,
Brian Lindahle887a252023-01-17 14:54:19 -0700121 std::vector<Color> desiredPixelColors) {
ramindanibab8ba92021-11-18 01:24:11 +0000122 ASSERT_TRUE(pixelFormat == common::PixelFormat::RGB_888 ||
123 pixelFormat == common::PixelFormat::RGBA_8888);
124 int32_t bytesPerPixel = GetBytesPerPixel(pixelFormat);
125 ASSERT_NE(-1, bytesPerPixel);
126 for (int row = 0; row < height; row++) {
127 for (int col = 0; col < width; col++) {
Brian Lindahle887a252023-01-17 14:54:19 -0700128 auto pixel = row * static_cast<int32_t>(width) + col;
129 Color srcColor = desiredPixelColors[static_cast<size_t>(pixel)];
ramindanibab8ba92021-11-18 01:24:11 +0000130
131 int offset = (row * static_cast<int32_t>(stride) + col) * bytesPerPixel;
132 uint8_t* pixelColor = (uint8_t*)bufferData + offset;
Brian Lindahle887a252023-01-17 14:54:19 -0700133 pixelColor[0] = static_cast<uint8_t>(std::round(255.0f * srcColor.r));
134 pixelColor[1] = static_cast<uint8_t>(std::round(255.0f * srcColor.g));
135 pixelColor[2] = static_cast<uint8_t>(std::round(255.0f * srcColor.b));
ramindanibab8ba92021-11-18 01:24:11 +0000136
137 if (bytesPerPixel == 4) {
Brian Lindahle887a252023-01-17 14:54:19 -0700138 pixelColor[3] = static_cast<uint8_t>(std::round(255.0f * srcColor.a));
ramindanibab8ba92021-11-18 01:24:11 +0000139 }
140 }
141 }
142}
143
Brian Lindahle887a252023-01-17 14:54:19 -0700144void ReadbackHelper::clearColors(std::vector<Color>& expectedColors, int32_t width, int32_t height,
ramindanibab8ba92021-11-18 01:24:11 +0000145 int32_t displayWidth) {
146 for (int row = 0; row < height; row++) {
147 for (int col = 0; col < width; col++) {
148 int pixel = row * displayWidth + col;
Brian Lindahle887a252023-01-17 14:54:19 -0700149 expectedColors[static_cast<size_t>(pixel)] = BLACK;
ramindanibab8ba92021-11-18 01:24:11 +0000150 }
151 }
152}
153
Brian Lindahle887a252023-01-17 14:54:19 -0700154void ReadbackHelper::fillColorsArea(std::vector<Color>& expectedColors, int32_t stride, Rect area,
155 Color color) {
ramindanibab8ba92021-11-18 01:24:11 +0000156 for (int row = area.top; row < area.bottom; row++) {
157 for (int col = area.left; col < area.right; col++) {
158 int pixel = row * stride + col;
Brian Lindahle887a252023-01-17 14:54:19 -0700159 expectedColors[static_cast<size_t>(pixel)] = color;
ramindanibab8ba92021-11-18 01:24:11 +0000160 }
161 }
162}
163
Brian Lindahle887a252023-01-17 14:54:19 -0700164bool ReadbackHelper::readbackSupported(const common::PixelFormat& pixelFormat,
165 const common::Dataspace& dataspace) {
166 if (pixelFormat != common::PixelFormat::RGB_888 &&
167 pixelFormat != common::PixelFormat::RGBA_8888) {
168 return false;
Brian Lindahld103cd62022-12-09 07:26:28 -0700169 }
Brian Lindahle887a252023-01-17 14:54:19 -0700170 if (std::find(dataspaces.begin(), dataspaces.end(), dataspace) == dataspaces.end()) {
171 return false;
172 }
173 return true;
174}
175
176void ReadbackHelper::compareColorBuffers(const std::vector<Color>& expectedColors, void* bufferData,
177 const uint32_t stride, const uint32_t width,
178 const uint32_t height, common::PixelFormat pixelFormat) {
179 const int32_t bytesPerPixel = ReadbackHelper::GetBytesPerPixel(pixelFormat);
ramindanibab8ba92021-11-18 01:24:11 +0000180 ASSERT_NE(-1, bytesPerPixel);
Brian Lindahle887a252023-01-17 14:54:19 -0700181 for (int row = 0; row < height; row++) {
182 for (int col = 0; col < width; col++) {
183 auto pixel = row * static_cast<int32_t>(width) + col;
Alec Mouri3e037cf2022-01-24 08:58:28 -0800184 int offset = (row * static_cast<int32_t>(stride) + col) * bytesPerPixel;
Brian Lindahle887a252023-01-17 14:54:19 -0700185 uint8_t* pixelColor = (uint8_t*)bufferData + offset;
Ady Abraham1bee7ab2022-01-06 17:22:08 -0800186 const Color expectedColor = expectedColors[static_cast<size_t>(pixel)];
Ady Abraham1bee7ab2022-01-06 17:22:08 -0800187 ASSERT_EQ(std::round(255.0f * expectedColor.r), pixelColor[0]);
188 ASSERT_EQ(std::round(255.0f * expectedColor.g), pixelColor[1]);
189 ASSERT_EQ(std::round(255.0f * expectedColor.b), pixelColor[2]);
ramindanibab8ba92021-11-18 01:24:11 +0000190 }
191 }
192}
193
Alec Mourif6c039a2023-10-06 23:02:17 +0000194void ReadbackHelper::compareColorBuffers(void* expectedBuffer, void* actualBuffer,
195 const uint32_t stride, const uint32_t width,
196 const uint32_t height, common::PixelFormat pixelFormat) {
197 const int32_t bytesPerPixel = ReadbackHelper::GetBytesPerPixel(pixelFormat);
198 ASSERT_NE(-1, bytesPerPixel);
199 for (int row = 0; row < height; row++) {
200 for (int col = 0; col < width; col++) {
201 int offset = (row * static_cast<int32_t>(stride) + col) * bytesPerPixel;
202 uint8_t* expectedColor = (uint8_t*)expectedBuffer + offset;
203 uint8_t* actualColor = (uint8_t*)actualBuffer + offset;
204 ASSERT_EQ(expectedColor[0], actualColor[0]);
205 ASSERT_EQ(expectedColor[1], actualColor[1]);
206 ASSERT_EQ(expectedColor[2], actualColor[2]);
207 }
208 }
209}
210
ramindanidcecfd42022-02-03 23:52:19 +0000211ReadbackBuffer::ReadbackBuffer(int64_t display, const std::shared_ptr<VtsComposerClient>& client,
Brian Lindahle887a252023-01-17 14:54:19 -0700212 int32_t width, int32_t height, common::PixelFormat pixelFormat,
213 common::Dataspace dataspace)
ramindanidcecfd42022-02-03 23:52:19 +0000214 : mComposerClient(client) {
ramindanibab8ba92021-11-18 01:24:11 +0000215 mDisplay = display;
Brian Lindahle887a252023-01-17 14:54:19 -0700216
217 mPixelFormat = pixelFormat;
218 mDataspace = dataspace;
219
ramindanibab8ba92021-11-18 01:24:11 +0000220 mWidth = static_cast<uint32_t>(width);
221 mHeight = static_cast<uint32_t>(height);
222 mLayerCount = 1;
223 mUsage = static_cast<uint64_t>(static_cast<uint64_t>(common::BufferUsage::CPU_READ_OFTEN) |
224 static_cast<uint64_t>(common::BufferUsage::GPU_TEXTURE));
Brian Lindahle887a252023-01-17 14:54:19 -0700225
226 mAccessRegion.top = 0;
227 mAccessRegion.left = 0;
228 mAccessRegion.right = static_cast<int32_t>(width);
229 mAccessRegion.bottom = static_cast<int32_t>(height);
230}
231
232::android::sp<::android::GraphicBuffer> ReadbackBuffer::allocateBuffer() {
233 return ::android::sp<::android::GraphicBuffer>::make(
234 mWidth, mHeight, static_cast<::android::PixelFormat>(mPixelFormat), mLayerCount, mUsage,
235 "ReadbackBuffer");
ramindanibab8ba92021-11-18 01:24:11 +0000236}
237
238void ReadbackBuffer::setReadbackBuffer() {
Brian Lindahle887a252023-01-17 14:54:19 -0700239 mGraphicBuffer = allocateBuffer();
ramindanibab8ba92021-11-18 01:24:11 +0000240 ASSERT_NE(nullptr, mGraphicBuffer);
241 ASSERT_EQ(::android::OK, mGraphicBuffer->initCheck());
Brian Lindahle887a252023-01-17 14:54:19 -0700242 const auto& bufferHandle = mGraphicBuffer->handle;
243 ::ndk::ScopedFileDescriptor fence = ::ndk::ScopedFileDescriptor(-1);
244 EXPECT_TRUE(mComposerClient->setReadbackBuffer(mDisplay, bufferHandle, fence).isOk());
ramindanibab8ba92021-11-18 01:24:11 +0000245}
246
ramindanidcecfd42022-02-03 23:52:19 +0000247void ReadbackBuffer::checkReadbackBuffer(const std::vector<Color>& expectedColors) {
Brian Lindahle887a252023-01-17 14:54:19 -0700248 ASSERT_NE(nullptr, mGraphicBuffer);
ramindanibab8ba92021-11-18 01:24:11 +0000249 // lock buffer for reading
ramindanidcecfd42022-02-03 23:52:19 +0000250 const auto& [fenceStatus, bufferFence] = mComposerClient->getReadbackBufferFence(mDisplay);
Brian Lindahle887a252023-01-17 14:54:19 -0700251 EXPECT_TRUE(fenceStatus.isOk());
252
253 int bytesPerPixel = -1;
254 int bytesPerStride = -1;
255 void* bufData = nullptr;
256
257 auto status = mGraphicBuffer->lockAsync(mUsage, mAccessRegion, &bufData, dup(bufferFence.get()),
258 &bytesPerPixel, &bytesPerStride);
259 EXPECT_EQ(::android::OK, status);
260 ASSERT_TRUE(mPixelFormat == PixelFormat::RGB_888 || mPixelFormat == PixelFormat::RGBA_8888);
261 const uint32_t stride = (bytesPerPixel > 0 && bytesPerStride > 0)
262 ? static_cast<uint32_t>(bytesPerStride / bytesPerPixel)
263 : mGraphicBuffer->getStride();
264 ReadbackHelper::compareColorBuffers(expectedColors, bufData, stride, mWidth, mHeight,
265 mPixelFormat);
266 status = mGraphicBuffer->unlock();
267 EXPECT_EQ(::android::OK, status);
ramindanibab8ba92021-11-18 01:24:11 +0000268}
269
Alec Mourif6c039a2023-10-06 23:02:17 +0000270::android::sp<::android::GraphicBuffer> ReadbackBuffer::getBuffer() {
271 const auto& [fenceStatus, bufferFence] = mComposerClient->getReadbackBufferFence(mDisplay);
272 EXPECT_TRUE(fenceStatus.isOk());
273 if (bufferFence.get() != -1) {
274 sync_wait(bufferFence.get(), -1);
275 }
276 return mGraphicBuffer;
277}
278
Ady Abraham91c9d1a2021-12-15 18:14:45 -0800279void TestColorLayer::write(ComposerClientWriter& writer) {
ramindanibab8ba92021-11-18 01:24:11 +0000280 TestLayer::write(writer);
Ady Abraham3192f3d2021-12-03 16:08:56 -0800281 writer.setLayerCompositionType(mDisplay, mLayer, Composition::SOLID_COLOR);
282 writer.setLayerColor(mDisplay, mLayer, mColor);
ramindanibab8ba92021-11-18 01:24:11 +0000283}
284
285LayerSettings TestColorLayer::toRenderEngineLayerSettings() {
286 LayerSettings layerSettings = TestLayer::toRenderEngineLayerSettings();
287
Ady Abraham1bee7ab2022-01-06 17:22:08 -0800288 layerSettings.source.solidColor = ::android::half3(mColor.r, mColor.g, mColor.b);
289 layerSettings.alpha = mAlpha * mColor.a;
ramindanibab8ba92021-11-18 01:24:11 +0000290 return layerSettings;
291}
292
ramindanidcecfd42022-02-03 23:52:19 +0000293TestBufferLayer::TestBufferLayer(const std::shared_ptr<VtsComposerClient>& client,
Ady Abraham4aa4ead2021-12-03 16:07:19 -0800294 TestRenderEngine& renderEngine, int64_t display, uint32_t width,
ramindanibab8ba92021-11-18 01:24:11 +0000295 uint32_t height, common::PixelFormat format,
Ady Abrahama00d2462023-12-26 14:21:20 -0800296 ComposerClientWriter& writer, Composition composition)
297 : TestLayer{client, display, writer}, mRenderEngine(renderEngine) {
ramindanibab8ba92021-11-18 01:24:11 +0000298 mComposition = composition;
299 mWidth = width;
300 mHeight = height;
301 mLayerCount = 1;
302 mPixelFormat = format;
303 mUsage = (static_cast<uint64_t>(common::BufferUsage::CPU_READ_OFTEN) |
304 static_cast<uint64_t>(common::BufferUsage::CPU_WRITE_OFTEN) |
305 static_cast<uint64_t>(common::BufferUsage::COMPOSER_OVERLAY) |
306 static_cast<uint64_t>(common::BufferUsage::GPU_TEXTURE));
307
308 mAccessRegion.top = 0;
309 mAccessRegion.left = 0;
310 mAccessRegion.right = static_cast<int32_t>(width);
311 mAccessRegion.bottom = static_cast<int32_t>(height);
312
313 setSourceCrop({0, 0, (float)width, (float)height});
314}
315
Ady Abraham91c9d1a2021-12-15 18:14:45 -0800316void TestBufferLayer::write(ComposerClientWriter& writer) {
ramindanibab8ba92021-11-18 01:24:11 +0000317 TestLayer::write(writer);
Ady Abraham3192f3d2021-12-03 16:08:56 -0800318 writer.setLayerCompositionType(mDisplay, mLayer, mComposition);
319 writer.setLayerVisibleRegion(mDisplay, mLayer, std::vector<Rect>(1, mDisplayFrame));
ramindani0a2bee42022-02-10 01:27:42 +0000320 if (mGraphicBuffer) {
321 writer.setLayerBuffer(mDisplay, mLayer, /*slot*/ 0, mGraphicBuffer->handle, mFillFence);
322 }
ramindanibab8ba92021-11-18 01:24:11 +0000323}
324
325LayerSettings TestBufferLayer::toRenderEngineLayerSettings() {
326 LayerSettings layerSettings = TestLayer::toRenderEngineLayerSettings();
Vishnu Nair59329712022-01-13 07:59:37 -0800327 layerSettings.source.buffer.buffer =
328 std::make_shared<::android::renderengine::impl::ExternalTexture>(
Alec Mouri3e037cf2022-01-24 08:58:28 -0800329 mGraphicBuffer, mRenderEngine.getInternalRenderEngine(),
Vishnu Nair59329712022-01-13 07:59:37 -0800330 ::android::renderengine::impl::ExternalTexture::Usage::READABLE);
ramindanibab8ba92021-11-18 01:24:11 +0000331
332 layerSettings.source.buffer.usePremultipliedAlpha = mBlendMode == BlendMode::PREMULTIPLIED;
333
334 const float scaleX = (mSourceCrop.right - mSourceCrop.left) / (static_cast<float>(mWidth));
335 const float scaleY = (mSourceCrop.bottom - mSourceCrop.top) / (static_cast<float>(mHeight));
336 const float translateX = mSourceCrop.left / (static_cast<float>(mWidth));
337 const float translateY = mSourceCrop.top / (static_cast<float>(mHeight));
338
339 layerSettings.source.buffer.textureTransform =
ramindanidcecfd42022-02-03 23:52:19 +0000340 ::android::mat4::translate(::android::vec4(translateX, translateY, 0.0f, 1.0f)) *
341 ::android::mat4::scale(::android::vec4(scaleX, scaleY, 1.0f, 1.0f));
ramindanibab8ba92021-11-18 01:24:11 +0000342
343 return layerSettings;
344}
345
346void TestBufferLayer::fillBuffer(std::vector<Color>& expectedColors) {
347 void* bufData;
Alec Mouri3e037cf2022-01-24 08:58:28 -0800348 int32_t bytesPerPixel = -1;
349 int32_t bytesPerStride = -1;
350 auto status = mGraphicBuffer->lock(mUsage, &bufData, &bytesPerPixel, &bytesPerStride);
351 const uint32_t stride = (bytesPerPixel > 0 && bytesPerStride > 0)
352 ? static_cast<uint32_t>(bytesPerStride / bytesPerPixel)
353 : mGraphicBuffer->getStride();
Brian Lindahle887a252023-01-17 14:54:19 -0700354 EXPECT_EQ(::android::OK, status);
355 ASSERT_NO_FATAL_FAILURE(ReadbackHelper::fillBuffer(mWidth, mHeight, stride, bufData,
356 mPixelFormat, expectedColors));
ramindani0a2bee42022-02-10 01:27:42 +0000357
358 const auto unlockStatus = mGraphicBuffer->unlockAsync(&mFillFence);
359 ASSERT_EQ(::android::OK, unlockStatus);
ramindanibab8ba92021-11-18 01:24:11 +0000360}
361
362void TestBufferLayer::setBuffer(std::vector<Color> colors) {
ramindani0a2bee42022-02-10 01:27:42 +0000363 mGraphicBuffer = allocateBuffer();
ramindanibab8ba92021-11-18 01:24:11 +0000364 ASSERT_NE(nullptr, mGraphicBuffer);
ramindanibab8ba92021-11-18 01:24:11 +0000365 ASSERT_EQ(::android::OK, mGraphicBuffer->initCheck());
Brian Lindahle887a252023-01-17 14:54:19 -0700366 ASSERT_NO_FATAL_FAILURE(fillBuffer(colors));
ramindani0a2bee42022-02-10 01:27:42 +0000367}
368
Brian Lindahle887a252023-01-17 14:54:19 -0700369::android::sp<::android::GraphicBuffer> TestBufferLayer::allocateBuffer() {
370 return ::android::sp<::android::GraphicBuffer>::make(
371 mWidth, mHeight, static_cast<::android::PixelFormat>(mPixelFormat), mLayerCount, mUsage,
372 "TestBufferLayer");
ramindanibab8ba92021-11-18 01:24:11 +0000373}
374
Ady Abraham91c9d1a2021-12-15 18:14:45 -0800375void TestBufferLayer::setToClientComposition(ComposerClientWriter& writer) {
Ady Abraham3192f3d2021-12-03 16:08:56 -0800376 writer.setLayerCompositionType(mDisplay, mLayer, Composition::CLIENT);
ramindanibab8ba92021-11-18 01:24:11 +0000377}
378
Ady Abraham3192f3d2021-12-03 16:08:56 -0800379} // namespace aidl::android::hardware::graphics::composer3::vts