1 /*
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 
17 #include <composer-vts/2.2/ComposerVts.h>
18 
19 #include <composer-command-buffer/2.2/ComposerCommandBuffer.h>
20 #include <hidl/HidlTransportUtils.h>
21 
22 namespace android {
23 namespace hardware {
24 namespace graphics {
25 namespace composer {
26 namespace V2_2 {
27 namespace vts {
28 
29 using details::canCastInterface;
30 using details::getDescriptor;
31 
createClient()32 std::unique_ptr<ComposerClient> Composer::createClient() {
33     std::unique_ptr<ComposerClient> client;
34     getRaw()->createClient([&](const auto& tmpError, const auto& tmpClient) {
35         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), "[email protected]::IComposerClient", false))
39             << "Cannot create 2.2 IComposerClient";
40         client = std::make_unique<ComposerClient>(IComposerClient::castFrom(tmpClient, true));
41     });
42 
43     return client;
44 }
45 
getRaw() const46 sp<IComposerClient> ComposerClient::getRaw() const {
47     return mClient;
48 }
49 
getPerFrameMetadataKeys(Display display)50 std::vector<IComposerClient::PerFrameMetadataKey> ComposerClient::getPerFrameMetadataKeys(
51     Display display) {
52     std::vector<IComposerClient::PerFrameMetadataKey> keys;
53     mClient->getPerFrameMetadataKeys(display, [&](const auto& tmpError, const auto& tmpKeys) {
54         ASSERT_EQ(Error::NONE, tmpError) << "failed to get HDR metadata keys";
55         keys = tmpKeys;
56     });
57 
58     return keys;
59 }
60 
execute(V2_1::vts::TestCommandReader * reader,CommandWriterBase * writer)61 void ComposerClient::execute(V2_1::vts::TestCommandReader* reader, CommandWriterBase* writer) {
62     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) {
68         auto ret = mClient->setInputCommandQueue(*writer->getMQDescriptor());
69         ASSERT_EQ(Error::NONE, static_cast<Error>(ret));
70     }
71 
72     mClient->executeCommands(commandLength, commandHandles,
73                              [&](const auto& tmpError, const auto& tmpOutQueueChanged,
74                                  const auto& tmpOutLength, const auto& tmpOutHandles) {
75                                  ASSERT_EQ(Error::NONE, tmpError);
76 
77                                  if (tmpOutQueueChanged) {
78                                      mClient->getOutputCommandQueue(
79                                          [&](const auto& tmpError, const auto& tmpDescriptor) {
80                                              ASSERT_EQ(Error::NONE, tmpError);
81                                              reader->setMQDescriptor(tmpDescriptor);
82                                          });
83                                  }
84 
85                                  ASSERT_TRUE(reader->readQueue(tmpOutLength, tmpOutHandles));
86                                  reader->parse();
87                              });
88     reader->reset();
89     writer->reset();
90 }
91 
createVirtualDisplay_2_2(uint32_t width,uint32_t height,PixelFormat formatHint,uint32_t outputBufferSlotCount,PixelFormat * outFormat)92 Display ComposerClient::createVirtualDisplay_2_2(uint32_t width, uint32_t height,
93                                                  PixelFormat formatHint,
94                                                  uint32_t outputBufferSlotCount,
95                                                  PixelFormat* outFormat) {
96     Display display = 0;
97     mClient->createVirtualDisplay_2_2(
98         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 
getClientTargetSupport_2_2(Display display,uint32_t width,uint32_t height,PixelFormat format,Dataspace dataspace)111 bool 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);
114     return error == Error::NONE;
115 }
116 
setPowerMode_2_2(Display display,IComposerClient::PowerMode mode)117 void ComposerClient::setPowerMode_2_2(Display display, IComposerClient::PowerMode mode) {
118     Error error = mClient->setPowerMode_2_2(display, mode);
119     ASSERT_TRUE(error == Error::NONE || error == Error::UNSUPPORTED) << "failed to set power mode";
120 }
121 
setReadbackBuffer(Display display,const native_handle_t * buffer,int32_t)122 void ComposerClient::setReadbackBuffer(Display display, const native_handle_t* buffer,
123                                        int32_t /* releaseFence */) {
124     // Ignoring fence, HIDL doesn't care
125     Error error = mClient->setReadbackBuffer(display, buffer, nullptr);
126     ASSERT_EQ(Error::NONE, error) << "failed to setReadbackBuffer";
127 }
128 
getReadbackBufferAttributes(Display display,PixelFormat * outPixelFormat,Dataspace * outDataspace)129 void ComposerClient::getReadbackBufferAttributes(Display display, PixelFormat* outPixelFormat,
130                                                  Dataspace* outDataspace) {
131     mClient->getReadbackBufferAttributes(
132         display,
133         [&](const auto& tmpError, const auto& tmpOutPixelFormat, const auto& tmpOutDataspace) {
134             ASSERT_EQ(Error::NONE, tmpError) << "failed to get readback buffer attributes";
135             *outPixelFormat = tmpOutPixelFormat;
136             *outDataspace = tmpOutDataspace;
137         });
138 }
139 
getReadbackBufferFence(Display display,int32_t * outFence)140 void ComposerClient::getReadbackBufferFence(Display display, int32_t* outFence) {
141     mClient->getReadbackBufferFence(display, [&](const auto& tmpError, const auto& tmpHandle) {
142         ASSERT_EQ(Error::NONE, tmpError) << "failed to get readback fence";
143         const native_handle_t* nativeFenceHandle = tmpHandle.getNativeHandle();
144         *outFence = dup(nativeFenceHandle->data[0]);
145     });
146 }
147 
getColorModes(Display display)148 std::vector<ColorMode> ComposerClient::getColorModes(Display display) {
149     std::vector<ColorMode> modes;
150     mClient->getColorModes_2_2(display, [&](const auto& tmpError, const auto& tmpModes) {
151         ASSERT_EQ(Error::NONE, tmpError) << "failed to get color modes";
152         modes = tmpModes;
153     });
154     return modes;
155 }
156 
getRenderIntents(Display display,ColorMode mode)157 std::vector<RenderIntent> ComposerClient::getRenderIntents(Display display, ColorMode mode) {
158     std::vector<RenderIntent> intents;
159     mClient->getRenderIntents(display, mode, [&](const auto& tmpError, const auto& tmpIntents) {
160         ASSERT_EQ(Error::NONE, tmpError) << "failed to get render intents";
161         intents = tmpIntents;
162     });
163     return intents;
164 }
165 
setColorMode(Display display,ColorMode mode,RenderIntent intent)166 void ComposerClient::setColorMode(Display display, ColorMode mode, RenderIntent intent) {
167     Error error = mClient->setColorMode_2_2(display, mode, intent);
168     ASSERT_TRUE(error == Error::NONE || error == Error::UNSUPPORTED) << "failed to set color mode";
169 }
170 
getDataspaceSaturationMatrix(Dataspace dataspace)171 std::array<float, 16> ComposerClient::getDataspaceSaturationMatrix(Dataspace dataspace) {
172     std::array<float, 16> matrix;
173     mClient->getDataspaceSaturationMatrix(
174         dataspace, [&](const auto& tmpError, const auto& tmpMatrix) {
175             ASSERT_EQ(Error::NONE, tmpError) << "failed to get datasapce saturation matrix";
176             std::copy_n(tmpMatrix.data(), matrix.size(), matrix.begin());
177         });
178 
179     return matrix;
180 }
181 
Gralloc()182 Gralloc::Gralloc() {
183     [this] {
184         ALOGD("Attempting to initialize gralloc4");
185         ASSERT_NO_FATAL_FAILURE(mGralloc4 = std::make_shared<Gralloc4>("default", "default",
186                                                                        /*errOnFailure=*/false));
187         if (mGralloc4->getMapper() == nullptr || mGralloc4->getAllocator() == nullptr) {
188             mGralloc4 = nullptr;
189             ALOGD("Failed to initialize gralloc4, initializing gralloc3");
190             ASSERT_NO_FATAL_FAILURE(mGralloc3 = std::make_shared<Gralloc3>("default", "default",
191                                                                            /*errOnFailure=*/false));
192             if (mGralloc3->getMapper() == nullptr || mGralloc3->getAllocator() == nullptr) {
193                 mGralloc3 = nullptr;
194                 ALOGD("Failed to initialize gralloc3, initializing gralloc2_1");
195                 mGralloc2_1 = std::make_shared<Gralloc2_1>(/*errOnFailure*/ false);
196                 if (!mGralloc2_1->getMapper()) {
197                     mGralloc2_1 = nullptr;
198                     ALOGD("Failed to initialize gralloc2_1, initializing gralloc2");
199                     ASSERT_NO_FATAL_FAILURE(mGralloc2 = std::make_shared<Gralloc2>());
200                 }
201             }
202         }
203     }();
204 }
205 
validateBufferSize(const native_handle_t * bufferHandle,uint32_t width,uint32_t height,uint32_t layerCount,PixelFormat format,uint64_t usage,uint32_t stride)206 bool Gralloc::validateBufferSize(const native_handle_t* bufferHandle, uint32_t width,
207                                  uint32_t height, uint32_t layerCount, PixelFormat format,
208                                  uint64_t usage, uint32_t stride) {
209     if (mGralloc4) {
210         IMapper4::BufferDescriptorInfo info{};
211         info.width = width;
212         info.height = height;
213         info.layerCount = layerCount;
214         info.format = static_cast<android::hardware::graphics::common::V1_2::PixelFormat>(format);
215         info.usage = usage;
216         return mGralloc4->validateBufferSize(bufferHandle, info, stride);
217     } else if (mGralloc3) {
218         IMapper3::BufferDescriptorInfo info{};
219         info.width = width;
220         info.height = height;
221         info.layerCount = layerCount;
222         info.format = static_cast<android::hardware::graphics::common::V1_2::PixelFormat>(format);
223         info.usage = usage;
224         return mGralloc3->validateBufferSize(bufferHandle, info, stride);
225     } else if (mGralloc2_1) {
226         IMapper2_1::BufferDescriptorInfo info{};
227         info.width = width;
228         info.height = height;
229         info.layerCount = layerCount;
230         info.format = static_cast<android::hardware::graphics::common::V1_1::PixelFormat>(format);
231         info.usage = usage;
232         return mGralloc2_1->validateBufferSize(bufferHandle, info, stride);
233     } else {
234         return true;
235     }
236 }
237 
238 }  // namespace vts
239 }  // namespace V2_2
240 }  // namespace composer
241 }  // namespace graphics
242 }  // namespace hardware
243 }  // namespace android
244