blob: a6dfcaf54b37fe66accc7e9fe154eee3f485a370 [file] [log] [blame]
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -08001/*
2 * Copyright (C) 2018 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
Chia-I Wu96a098a2018-01-25 10:38:06 -080017#include <composer-vts/2.2/ComposerVts.h>
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -080018
19#include <composer-command-buffer/2.2/ComposerCommandBuffer.h>
Chia-I Wu96a098a2018-01-25 10:38:06 -080020#include <hidl/HidlTransportUtils.h>
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -080021
22namespace android {
23namespace hardware {
24namespace graphics {
25namespace composer {
26namespace V2_2 {
Chia-I Wu96a098a2018-01-25 10:38:06 -080027namespace vts {
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -080028
Dominik Laskowski0c415582018-04-02 15:35:00 -070029using details::canCastInterface;
30using details::getDescriptor;
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -080031
Dominik Laskowski0c415582018-04-02 15:35:00 -070032std::unique_ptr<ComposerClient> Composer::createClient() {
33 std::unique_ptr<ComposerClient> client;
34 getRaw()->createClient([&](const auto& tmpError, const auto& tmpClient) {
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -080035 ASSERT_EQ(Error::NONE, tmpError) << "failed to create client";
36 ALOGV("tmpClient is a %s", getDescriptor(&(*tmpClient)).c_str());
37 ASSERT_TRUE(canCastInterface(
38 &(*tmpClient), "android.hardware.graphics.composer@2.2::IComposerClient", false))
39 << "Cannot create 2.2 IComposerClient";
Dominik Laskowski0c415582018-04-02 15:35:00 -070040 client = std::make_unique<ComposerClient>(IComposerClient::castFrom(tmpClient, true));
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -080041 });
42
43 return client;
44}
45
Chia-I Wu76630c62018-05-22 12:52:36 -070046sp<IComposerClient> ComposerClient::getRaw() const {
47 return mClient;
48}
49
Dominik Laskowski0c415582018-04-02 15:35:00 -070050std::vector<IComposerClient::PerFrameMetadataKey> ComposerClient::getPerFrameMetadataKeys(
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -080051 Display display) {
52 std::vector<IComposerClient::PerFrameMetadataKey> keys;
Dominik Laskowski0c415582018-04-02 15:35:00 -070053 mClient->getPerFrameMetadataKeys(display, [&](const auto& tmpError, const auto& tmpKeys) {
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -080054 ASSERT_EQ(Error::NONE, tmpError) << "failed to get HDR metadata keys";
55 keys = tmpKeys;
56 });
57
58 return keys;
59}
60
Dominik Laskowski0c415582018-04-02 15:35:00 -070061void ComposerClient::execute(V2_1::vts::TestCommandReader* reader, CommandWriterBase* writer) {
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -080062 bool queueChanged = false;
63 uint32_t commandLength = 0;
64 hidl_vec<hidl_handle> commandHandles;
65 ASSERT_TRUE(writer->writeQueue(&queueChanged, &commandLength, &commandHandles));
66
67 if (queueChanged) {
Dominik Laskowski0c415582018-04-02 15:35:00 -070068 auto ret = mClient->setInputCommandQueue(*writer->getMQDescriptor());
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -080069 ASSERT_EQ(Error::NONE, static_cast<Error>(ret));
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -080070 }
71
Dominik Laskowski0c415582018-04-02 15:35:00 -070072 mClient->executeCommands(commandLength, commandHandles,
73 [&](const auto& tmpError, const auto& tmpOutQueueChanged,
74 const auto& tmpOutLength, const auto& tmpOutHandles) {
75 ASSERT_EQ(Error::NONE, tmpError);
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -080076
Dominik Laskowski0c415582018-04-02 15:35:00 -070077 if (tmpOutQueueChanged) {
78 mClient->getOutputCommandQueue(
79 [&](const auto& tmpError, const auto& tmpDescriptor) {
80 ASSERT_EQ(Error::NONE, tmpError);
81 reader->setMQDescriptor(tmpDescriptor);
82 });
83 }
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -080084
Dominik Laskowski0c415582018-04-02 15:35:00 -070085 ASSERT_TRUE(reader->readQueue(tmpOutLength, tmpOutHandles));
86 reader->parse();
87 });
Valerie Haucbe8e9a2018-09-17 10:58:03 -070088 reader->reset();
89 writer->reset();
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -080090}
91
Dominik Laskowski0c415582018-04-02 15:35:00 -070092Display ComposerClient::createVirtualDisplay_2_2(uint32_t width, uint32_t height,
93 PixelFormat formatHint,
94 uint32_t outputBufferSlotCount,
95 PixelFormat* outFormat) {
Peiyong Lina2acfa22018-03-28 12:09:42 -070096 Display display = 0;
Dominik Laskowski0c415582018-04-02 15:35:00 -070097 mClient->createVirtualDisplay_2_2(
Peiyong Lina2acfa22018-03-28 12:09:42 -070098 width, height, formatHint, outputBufferSlotCount,
99 [&](const auto& tmpError, const auto& tmpDisplay, const auto& tmpFormat) {
100 ASSERT_EQ(Error::NONE, tmpError) << "failed to create virtual display";
101 display = tmpDisplay;
102 *outFormat = tmpFormat;
103
104 ASSERT_TRUE(mDisplayResources.insert({display, DisplayResource(true)}).second)
105 << "duplicated virtual display id " << display;
106 });
107
108 return display;
109}
110
Dominik Laskowski0c415582018-04-02 15:35:00 -0700111bool ComposerClient::getClientTargetSupport_2_2(Display display, uint32_t width, uint32_t height,
112 PixelFormat format, Dataspace dataspace) {
113 Error error = mClient->getClientTargetSupport_2_2(display, width, height, format, dataspace);
Peiyong Lina2acfa22018-03-28 12:09:42 -0700114 return error == Error::NONE;
115}
116
Dominik Laskowski0c415582018-04-02 15:35:00 -0700117void ComposerClient::setPowerMode_2_2(Display display, IComposerClient::PowerMode mode) {
118 Error error = mClient->setPowerMode_2_2(display, mode);
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -0800119 ASSERT_TRUE(error == Error::NONE || error == Error::UNSUPPORTED) << "failed to set power mode";
120}
121
Dominik Laskowski0c415582018-04-02 15:35:00 -0700122void ComposerClient::setReadbackBuffer(Display display, const native_handle_t* buffer,
123 int32_t /* releaseFence */) {
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -0800124 // Ignoring fence, HIDL doesn't care
Dominik Laskowski0c415582018-04-02 15:35:00 -0700125 Error error = mClient->setReadbackBuffer(display, buffer, nullptr);
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -0800126 ASSERT_EQ(Error::NONE, error) << "failed to setReadbackBuffer";
127}
128
Brian Lindahld103cd62022-12-09 07:26:28 -0700129void ComposerClient::getRequiredReadbackBufferAttributes(Display display,
130 PixelFormat* outPixelFormat,
131 Dataspace* outDataspace) {
132 ASSERT_EQ(Error::NONE, getReadbackBufferAttributes(display, outPixelFormat, outDataspace));
133}
134
135Error ComposerClient::getReadbackBufferAttributes(Display display, PixelFormat* outPixelFormat,
136 Dataspace* outDataspace) {
137 Error error;
Dominik Laskowski0c415582018-04-02 15:35:00 -0700138 mClient->getReadbackBufferAttributes(
Brian Lindahld103cd62022-12-09 07:26:28 -0700139 display, [&](const Error& tmpError, const PixelFormat& tmpPixelFormat,
140 const Dataspace& tmpDataspace) {
141 error = tmpError;
142 *outPixelFormat = tmpPixelFormat;
143 *outDataspace = tmpDataspace;
144 });
145 return error;
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -0800146}
147
Dominik Laskowski0c415582018-04-02 15:35:00 -0700148void ComposerClient::getReadbackBufferFence(Display display, int32_t* outFence) {
Dominik Laskowski0c415582018-04-02 15:35:00 -0700149 mClient->getReadbackBufferFence(display, [&](const auto& tmpError, const auto& tmpHandle) {
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -0800150 ASSERT_EQ(Error::NONE, tmpError) << "failed to get readback fence";
Valerie Hau667f11a2018-08-01 12:58:44 -0700151 const native_handle_t* nativeFenceHandle = tmpHandle.getNativeHandle();
152 *outFence = dup(nativeFenceHandle->data[0]);
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -0800153 });
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -0800154}
155
Dominik Laskowski0c415582018-04-02 15:35:00 -0700156std::vector<ColorMode> ComposerClient::getColorModes(Display display) {
Chia-I Wu6c8257f2018-02-28 12:24:42 -0800157 std::vector<ColorMode> modes;
Dominik Laskowski0c415582018-04-02 15:35:00 -0700158 mClient->getColorModes_2_2(display, [&](const auto& tmpError, const auto& tmpModes) {
Chia-I Wu6c8257f2018-02-28 12:24:42 -0800159 ASSERT_EQ(Error::NONE, tmpError) << "failed to get color modes";
160 modes = tmpModes;
161 });
162 return modes;
163}
164
Dominik Laskowski0c415582018-04-02 15:35:00 -0700165std::vector<RenderIntent> ComposerClient::getRenderIntents(Display display, ColorMode mode) {
Chia-I Wu6c8257f2018-02-28 12:24:42 -0800166 std::vector<RenderIntent> intents;
Dominik Laskowski0c415582018-04-02 15:35:00 -0700167 mClient->getRenderIntents(display, mode, [&](const auto& tmpError, const auto& tmpIntents) {
168 ASSERT_EQ(Error::NONE, tmpError) << "failed to get render intents";
169 intents = tmpIntents;
170 });
Chia-I Wu6c8257f2018-02-28 12:24:42 -0800171 return intents;
172}
173
Dominik Laskowski0c415582018-04-02 15:35:00 -0700174void ComposerClient::setColorMode(Display display, ColorMode mode, RenderIntent intent) {
175 Error error = mClient->setColorMode_2_2(display, mode, intent);
Chia-I Wu6c8257f2018-02-28 12:24:42 -0800176 ASSERT_TRUE(error == Error::NONE || error == Error::UNSUPPORTED) << "failed to set color mode";
177}
178
Dominik Laskowski0c415582018-04-02 15:35:00 -0700179std::array<float, 16> ComposerClient::getDataspaceSaturationMatrix(Dataspace dataspace) {
Chia-I Wu6c8257f2018-02-28 12:24:42 -0800180 std::array<float, 16> matrix;
Dominik Laskowski0c415582018-04-02 15:35:00 -0700181 mClient->getDataspaceSaturationMatrix(
Chia-I Wu6c8257f2018-02-28 12:24:42 -0800182 dataspace, [&](const auto& tmpError, const auto& tmpMatrix) {
183 ASSERT_EQ(Error::NONE, tmpError) << "failed to get datasapce saturation matrix";
184 std::copy_n(tmpMatrix.data(), matrix.size(), matrix.begin());
185 });
186
187 return matrix;
188}
189
Valerie Hauc1dc3132019-06-13 09:49:44 -0700190Gralloc::Gralloc() {
191 [this] {
Marissa Wall53aff112019-06-20 13:49:21 -0700192 ALOGD("Attempting to initialize gralloc4");
ramindanib2b747f2022-06-04 00:16:44 +0000193 ASSERT_NO_FATAL_FAILURE(mGralloc4 = std::make_shared<Gralloc4>(
194 /*aidlAllocatorServiceName*/ IAllocator::descriptor +
195 std::string("/default"),
196 /*hidlAllocatorServiceName*/ "default",
197 /*mapperServiceName*/ "default",
198 /*errOnFailure=*/false));
Alec Mouri38ccfd72022-05-16 20:20:28 +0000199 if (mGralloc4->getMapper() == nullptr || !mGralloc4->hasAllocator()) {
Marissa Wall53aff112019-06-20 13:49:21 -0700200 mGralloc4 = nullptr;
201 ALOGD("Failed to initialize gralloc4, initializing gralloc3");
202 ASSERT_NO_FATAL_FAILURE(mGralloc3 = std::make_shared<Gralloc3>("default", "default",
203 /*errOnFailure=*/false));
204 if (mGralloc3->getMapper() == nullptr || mGralloc3->getAllocator() == nullptr) {
205 mGralloc3 = nullptr;
206 ALOGD("Failed to initialize gralloc3, initializing gralloc2_1");
207 mGralloc2_1 = std::make_shared<Gralloc2_1>(/*errOnFailure*/ false);
208 if (!mGralloc2_1->getMapper()) {
209 mGralloc2_1 = nullptr;
210 ALOGD("Failed to initialize gralloc2_1, initializing gralloc2");
211 ASSERT_NO_FATAL_FAILURE(mGralloc2 = std::make_shared<Gralloc2>());
212 }
Valerie Hauc1dc3132019-06-13 09:49:44 -0700213 }
214 }
215 }();
216}
217
218bool Gralloc::validateBufferSize(const native_handle_t* bufferHandle, uint32_t width,
219 uint32_t height, uint32_t layerCount, PixelFormat format,
220 uint64_t usage, uint32_t stride) {
Marissa Wall53aff112019-06-20 13:49:21 -0700221 if (mGralloc4) {
222 IMapper4::BufferDescriptorInfo info{};
223 info.width = width;
224 info.height = height;
225 info.layerCount = layerCount;
226 info.format = static_cast<android::hardware::graphics::common::V1_2::PixelFormat>(format);
227 info.usage = usage;
228 return mGralloc4->validateBufferSize(bufferHandle, info, stride);
229 } else if (mGralloc3) {
Valerie Hauc1dc3132019-06-13 09:49:44 -0700230 IMapper3::BufferDescriptorInfo info{};
231 info.width = width;
232 info.height = height;
233 info.layerCount = layerCount;
234 info.format = static_cast<android::hardware::graphics::common::V1_2::PixelFormat>(format);
235 info.usage = usage;
236 return mGralloc3->validateBufferSize(bufferHandle, info, stride);
237 } else if (mGralloc2_1) {
238 IMapper2_1::BufferDescriptorInfo info{};
239 info.width = width;
240 info.height = height;
241 info.layerCount = layerCount;
242 info.format = static_cast<android::hardware::graphics::common::V1_1::PixelFormat>(format);
243 info.usage = usage;
244 return mGralloc2_1->validateBufferSize(bufferHandle, info, stride);
245 } else {
246 return true;
247 }
248}
249
Chia-I Wu96a098a2018-01-25 10:38:06 -0800250} // namespace vts
Courtney Goeltzenleuchterbe92bb92018-01-11 08:50:03 -0800251} // namespace V2_2
252} // namespace composer
253} // namespace graphics
254} // namespace hardware
255} // namespace android