blob: a1be311eae32bb2963b11f39d631b9e361a3b67d [file] [log] [blame]
Chia-I Wuaab99f52016-10-05 12:59:58 +08001/*
2 * Copyright 2016 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#ifndef ANDROID_SF_COMPOSER_HAL_H
18#define ANDROID_SF_COMPOSER_HAL_H
19
Chia-I Wucd8d7f02016-11-16 11:02:31 +080020#include <memory>
Dominik Laskowski13948602021-03-08 20:48:28 -080021#include <optional>
Chia-I Wuaab99f52016-10-05 12:59:58 +080022#include <string>
Chia-I Wucd8d7f02016-11-16 11:02:31 +080023#include <unordered_map>
24#include <utility>
Chia-I Wuaab99f52016-10-05 12:59:58 +080025#include <vector>
26
Ady Abraham8a82ba62020-01-17 12:43:17 -080027// TODO(b/129481165): remove the #pragma below and fix conversion issues
28#pragma clang diagnostic push
29#pragma clang diagnostic ignored "-Wconversion"
Marin Shalamanovbed7fd32020-12-21 20:02:20 +010030#pragma clang diagnostic ignored "-Wextra"
Ady Abraham8a82ba62020-01-17 12:43:17 -080031
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -070032#include <android/hardware/graphics/composer/2.4/IComposer.h>
33#include <android/hardware/graphics/composer/2.4/IComposerClient.h>
Ady Abrahame7385f72021-09-05 00:54:25 -070034
35#include <aidl/android/hardware/graphics/composer3/IComposer.h>
36#include <aidl/android/hardware/graphics/composer3/IComposerClient.h>
37#include <android/hardware/graphics/composer3/command-buffer.h>
38
Peiyong Linafa0f572020-01-13 16:35:02 -080039#include <composer-command-buffer/2.4/ComposerCommandBuffer.h>
Alec Mourie7cc1c22021-04-27 15:23:26 -070040#include <gui/BufferQueue.h>
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -070041#include <gui/HdrMetadata.h>
Peiyong Lin0e7a7912018-04-05 14:36:36 -070042#include <math/mat4.h>
Kevin DuBois1d4249a2018-08-29 10:45:14 -070043#include <ui/DisplayedFrameStats.h>
Lloyd Piqued0094aa2017-12-20 16:43:28 -080044#include <ui/GraphicBuffer.h>
Chia-I Wuaab99f52016-10-05 12:59:58 +080045#include <utils/StrongPointer.h>
46
Ady Abraham8a82ba62020-01-17 12:43:17 -080047// TODO(b/129481165): remove the #pragma below and fix conversion issues
Marin Shalamanovbed7fd32020-12-21 20:02:20 +010048#pragma clang diagnostic pop // ignored "-Wconversion -Wextra"
Ady Abraham8a82ba62020-01-17 12:43:17 -080049
Chia-I Wuaab99f52016-10-05 12:59:58 +080050namespace android {
51
52namespace Hwc2 {
53
Dominik Laskowski6231aaf2018-04-02 17:10:23 -070054namespace types = hardware::graphics::common;
Chia-I Wuaab99f52016-10-05 12:59:58 +080055
Dominik Laskowski6231aaf2018-04-02 17:10:23 -070056namespace V2_1 = hardware::graphics::composer::V2_1;
57namespace V2_2 = hardware::graphics::composer::V2_2;
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -070058namespace V2_3 = hardware::graphics::composer::V2_3;
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -070059namespace V2_4 = hardware::graphics::composer::V2_4;
Chia-I Wuaab99f52016-10-05 12:59:58 +080060
Dominik Laskowski6231aaf2018-04-02 17:10:23 -070061using types::V1_0::ColorTransform;
Dominik Laskowski6231aaf2018-04-02 17:10:23 -070062using types::V1_0::Transform;
Dominik Laskowski6231aaf2018-04-02 17:10:23 -070063using types::V1_1::RenderIntent;
Valerie Hau9758ae02018-10-09 16:05:09 -070064using types::V1_2::ColorMode;
65using types::V1_2::Dataspace;
Valerie Haue9e843a2018-12-18 13:39:23 -080066using types::V1_2::Hdr;
Kevin DuBois73d0f482019-01-25 11:18:03 -080067using types::V1_2::PixelFormat;
Valerie Haue9e843a2018-12-18 13:39:23 -080068
Dominik Laskowski6231aaf2018-04-02 17:10:23 -070069using V2_1::Config;
70using V2_1::Display;
71using V2_1::Error;
Dominik Laskowski6231aaf2018-04-02 17:10:23 -070072using V2_1::Layer;
Peiyong Linafa0f572020-01-13 16:35:02 -080073using V2_4::CommandReaderBase;
74using V2_4::CommandWriterBase;
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -070075using V2_4::IComposer;
Ady Abraham7159f572019-10-11 11:10:18 -070076using V2_4::IComposerCallback;
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -070077using V2_4::IComposerClient;
Ady Abraham7159f572019-10-11 11:10:18 -070078using V2_4::VsyncPeriodChangeTimeline;
79using V2_4::VsyncPeriodNanos;
Peiyong Lined531a32018-10-26 18:27:56 -070080using DisplayCapability = IComposerClient::DisplayCapability;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070081using PerFrameMetadata = IComposerClient::PerFrameMetadata;
82using PerFrameMetadataKey = IComposerClient::PerFrameMetadataKey;
Valerie Haue9e843a2018-12-18 13:39:23 -080083using PerFrameMetadataBlob = IComposerClient::PerFrameMetadataBlob;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070084
Ady Abrahame7385f72021-09-05 00:54:25 -070085using AidlCommandWriterBase = aidl::android::hardware::graphics::composer3::CommandWriterBase;
86using AidlCommandReaderBase = aidl::android::hardware::graphics::composer3::CommandReaderBase;
87
88class AidlIComposerCallbackWrapper;
89
Lloyd Piquea822d522017-12-20 16:42:57 -080090class Composer {
91public:
92 virtual ~Composer() = 0;
93
94 virtual std::vector<IComposer::Capability> getCapabilities() = 0;
95 virtual std::string dumpDebugInfo() = 0;
96
97 virtual void registerCallback(const sp<IComposerCallback>& callback) = 0;
98
Lloyd Piquea822d522017-12-20 16:42:57 -080099 // Reset all pending commands in the command buffer. Useful if you want to
100 // skip a frame but have already queued some commands.
101 virtual void resetCommands() = 0;
102
103 // Explicitly flush all pending commands in the command buffer.
104 virtual Error executeCommands() = 0;
105
106 virtual uint32_t getMaxVirtualDisplayCount() = 0;
Dominik Laskowski13948602021-03-08 20:48:28 -0800107 virtual Error createVirtualDisplay(uint32_t width, uint32_t height, PixelFormat*,
Dominik Laskowski263eec42021-07-21 23:13:24 -0700108 Display* outDisplay) = 0;
Lloyd Piquea822d522017-12-20 16:42:57 -0800109 virtual Error destroyVirtualDisplay(Display display) = 0;
110
111 virtual Error acceptDisplayChanges(Display display) = 0;
112
113 virtual Error createLayer(Display display, Layer* outLayer) = 0;
114 virtual Error destroyLayer(Display display, Layer layer) = 0;
115
116 virtual Error getActiveConfig(Display display, Config* outConfig) = 0;
117 virtual Error getChangedCompositionTypes(
118 Display display, std::vector<Layer>* outLayers,
119 std::vector<IComposerClient::Composition>* outTypes) = 0;
120 virtual Error getColorModes(Display display, std::vector<ColorMode>* outModes) = 0;
121 virtual Error getDisplayAttribute(Display display, Config config,
122 IComposerClient::Attribute attribute, int32_t* outValue) = 0;
123 virtual Error getDisplayConfigs(Display display, std::vector<Config>* outConfigs) = 0;
124 virtual Error getDisplayName(Display display, std::string* outName) = 0;
125
126 virtual Error getDisplayRequests(Display display, uint32_t* outDisplayRequestMask,
127 std::vector<Layer>* outLayers,
128 std::vector<uint32_t>* outLayerRequestMasks) = 0;
129
Lloyd Piquea822d522017-12-20 16:42:57 -0800130 virtual Error getDozeSupport(Display display, bool* outSupport) = 0;
131 virtual Error getHdrCapabilities(Display display, std::vector<Hdr>* outTypes,
132 float* outMaxLuminance, float* outMaxAverageLuminance,
133 float* outMinLuminance) = 0;
134
135 virtual Error getReleaseFences(Display display, std::vector<Layer>* outLayers,
136 std::vector<int>* outReleaseFences) = 0;
137
138 virtual Error presentDisplay(Display display, int* outPresentFence) = 0;
139
140 virtual Error setActiveConfig(Display display, Config config) = 0;
141
142 /*
143 * The composer caches client targets internally. When target is nullptr,
144 * the composer uses slot to look up the client target from its cache.
145 * When target is not nullptr, the cache is updated with the new target.
146 */
147 virtual Error setClientTarget(Display display, uint32_t slot, const sp<GraphicBuffer>& target,
148 int acquireFence, Dataspace dataspace,
149 const std::vector<IComposerClient::Rect>& damage) = 0;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700150 virtual Error setColorMode(Display display, ColorMode mode, RenderIntent renderIntent) = 0;
Lloyd Piquea822d522017-12-20 16:42:57 -0800151 virtual Error setColorTransform(Display display, const float* matrix, ColorTransform hint) = 0;
152 virtual Error setOutputBuffer(Display display, const native_handle_t* buffer,
153 int releaseFence) = 0;
154 virtual Error setPowerMode(Display display, IComposerClient::PowerMode mode) = 0;
155 virtual Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled) = 0;
156
157 virtual Error setClientTargetSlotCount(Display display) = 0;
158
159 virtual Error validateDisplay(Display display, uint32_t* outNumTypes,
160 uint32_t* outNumRequests) = 0;
161
162 virtual Error presentOrValidateDisplay(Display display, uint32_t* outNumTypes,
163 uint32_t* outNumRequests, int* outPresentFence,
164 uint32_t* state) = 0;
165
166 virtual Error setCursorPosition(Display display, Layer layer, int32_t x, int32_t y) = 0;
167 /* see setClientTarget for the purpose of slot */
168 virtual Error setLayerBuffer(Display display, Layer layer, uint32_t slot,
169 const sp<GraphicBuffer>& buffer, int acquireFence) = 0;
170 virtual Error setLayerSurfaceDamage(Display display, Layer layer,
171 const std::vector<IComposerClient::Rect>& damage) = 0;
172 virtual Error setLayerBlendMode(Display display, Layer layer,
173 IComposerClient::BlendMode mode) = 0;
174 virtual Error setLayerColor(Display display, Layer layer,
175 const IComposerClient::Color& color) = 0;
176 virtual Error setLayerCompositionType(Display display, Layer layer,
177 IComposerClient::Composition type) = 0;
178 virtual Error setLayerDataspace(Display display, Layer layer, Dataspace dataspace) = 0;
179 virtual Error setLayerDisplayFrame(Display display, Layer layer,
180 const IComposerClient::Rect& frame) = 0;
181 virtual Error setLayerPlaneAlpha(Display display, Layer layer, float alpha) = 0;
182 virtual Error setLayerSidebandStream(Display display, Layer layer,
183 const native_handle_t* stream) = 0;
184 virtual Error setLayerSourceCrop(Display display, Layer layer,
185 const IComposerClient::FRect& crop) = 0;
186 virtual Error setLayerTransform(Display display, Layer layer, Transform transform) = 0;
187 virtual Error setLayerVisibleRegion(Display display, Layer layer,
188 const std::vector<IComposerClient::Rect>& visible) = 0;
189 virtual Error setLayerZOrder(Display display, Layer layer, uint32_t z) = 0;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700190
191 // Composer HAL 2.2
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700192 virtual Error setLayerPerFrameMetadata(
193 Display display, Layer layer,
194 const std::vector<IComposerClient::PerFrameMetadata>& perFrameMetadatas) = 0;
Chia-I Wud7e01d72018-06-21 13:39:09 +0800195 virtual std::vector<IComposerClient::PerFrameMetadataKey> getPerFrameMetadataKeys(
196 Display display) = 0;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700197 virtual Error getRenderIntents(Display display, ColorMode colorMode,
198 std::vector<RenderIntent>* outRenderIntents) = 0;
199 virtual Error getDataspaceSaturationMatrix(Dataspace dataspace, mat4* outMatrix) = 0;
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700200
201 // Composer HAL 2.3
202 virtual Error getDisplayIdentificationData(Display display, uint8_t* outPort,
203 std::vector<uint8_t>* outData) = 0;
Peiyong Lin698147a2018-09-14 13:27:18 -0700204 virtual Error setLayerColorTransform(Display display, Layer layer,
205 const float* matrix) = 0;
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700206 virtual Error getDisplayedContentSamplingAttributes(Display display, PixelFormat* outFormat,
207 Dataspace* outDataspace,
208 uint8_t* outComponentMask) = 0;
Kevin DuBois74e53772018-11-19 10:52:38 -0800209 virtual Error setDisplayContentSamplingEnabled(Display display, bool enabled,
210 uint8_t componentMask, uint64_t maxFrames) = 0;
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700211 virtual Error getDisplayedContentSample(Display display, uint64_t maxFrames, uint64_t timestamp,
212 DisplayedFrameStats* outStats) = 0;
Valerie Haue9e843a2018-12-18 13:39:23 -0800213 virtual Error setLayerPerFrameMetadataBlobs(
214 Display display, Layer layer, const std::vector<PerFrameMetadataBlob>& metadata) = 0;
Dan Gittik57e63c52019-01-18 16:37:54 +0000215 virtual Error setDisplayBrightness(Display display, float brightness) = 0;
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -0700216
217 // Composer HAL 2.4
Ady Abraham7159f572019-10-11 11:10:18 -0700218 virtual bool isVsyncPeriodSwitchSupported() = 0;
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -0700219 virtual Error getDisplayCapabilities(Display display,
220 std::vector<DisplayCapability>* outCapabilities) = 0;
Ady Abraham7159f572019-10-11 11:10:18 -0700221 virtual V2_4::Error getDisplayConnectionType(
222 Display display, IComposerClient::DisplayConnectionType* outType) = 0;
223 virtual V2_4::Error getDisplayVsyncPeriod(Display display,
224 VsyncPeriodNanos* outVsyncPeriod) = 0;
225 virtual V2_4::Error setActiveConfigWithConstraints(
226 Display display, Config config,
227 const IComposerClient::VsyncPeriodChangeConstraints& vsyncPeriodChangeConstraints,
228 VsyncPeriodChangeTimeline* outTimeline) = 0;
Galia Peycheva5492cb52019-10-30 14:13:16 +0100229
230 virtual V2_4::Error setAutoLowLatencyMode(Display displayId, bool on) = 0;
231 virtual V2_4::Error getSupportedContentTypes(
232 Display displayId,
233 std::vector<IComposerClient::ContentType>* outSupportedContentTypes) = 0;
234 virtual V2_4::Error setContentType(Display displayId,
235 IComposerClient::ContentType contentType) = 0;
Dan Stoza18d48cb2019-10-21 15:39:24 -0700236 virtual V2_4::Error setLayerGenericMetadata(Display display, Layer layer,
237 const std::string& key, bool mandatory,
238 const std::vector<uint8_t>& value) = 0;
239 virtual V2_4::Error getLayerGenericMetadataKeys(
240 std::vector<IComposerClient::LayerGenericMetadataKey>* outKeys) = 0;
Peiyong Lindfc3f7c2020-05-07 20:15:50 -0700241 virtual Error getClientTargetProperty(
242 Display display, IComposerClient::ClientTargetProperty* outClientTargetProperty) = 0;
Lloyd Piquea822d522017-12-20 16:42:57 -0800243};
244
245namespace impl {
246
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800247class CommandReader : public CommandReaderBase {
248public:
249 ~CommandReader();
250
251 // Parse and execute commands from the command queue. The commands are
252 // actually return values from the server and will be saved in ReturnData.
253 Error parse();
254
255 // Get and clear saved errors.
256 struct CommandError {
257 uint32_t location;
258 Error error;
259 };
260 std::vector<CommandError> takeErrors();
261
Chia-I Wu67e376d2016-12-19 11:36:22 +0800262 bool hasChanges(Display display, uint32_t* outNumChangedCompositionTypes,
263 uint32_t* outNumLayerRequestMasks) const;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800264
265 // Get and clear saved changed composition types.
266 void takeChangedCompositionTypes(Display display,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800267 std::vector<Layer>* outLayers,
268 std::vector<IComposerClient::Composition>* outTypes);
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800269
270 // Get and clear saved display requests.
271 void takeDisplayRequests(Display display,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800272 uint32_t* outDisplayRequestMask, std::vector<Layer>* outLayers,
273 std::vector<uint32_t>* outLayerRequestMasks);
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800274
275 // Get and clear saved release fences.
Chia-I Wu67e376d2016-12-19 11:36:22 +0800276 void takeReleaseFences(Display display, std::vector<Layer>* outLayers,
277 std::vector<int>* outReleaseFences);
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800278
279 // Get and clear saved present fence.
Chia-I Wu67e376d2016-12-19 11:36:22 +0800280 void takePresentFence(Display display, int* outPresentFence);
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800281
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700282 // Get what stage succeeded during PresentOrValidate: Present or Validate
283 void takePresentOrValidateStage(Display display, uint32_t * state);
284
Peiyong Lindfc3f7c2020-05-07 20:15:50 -0700285 // Get the client target properties requested by hardware composer.
286 void takeClientTargetProperty(Display display,
287 IComposerClient::ClientTargetProperty* outClientTargetProperty);
288
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800289private:
290 void resetData();
291
292 bool parseSelectDisplay(uint16_t length);
293 bool parseSetError(uint16_t length);
294 bool parseSetChangedCompositionTypes(uint16_t length);
295 bool parseSetDisplayRequests(uint16_t length);
296 bool parseSetPresentFence(uint16_t length);
297 bool parseSetReleaseFences(uint16_t length);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700298 bool parseSetPresentOrValidateDisplayResult(uint16_t length);
Peiyong Linafa0f572020-01-13 16:35:02 -0800299 bool parseSetClientTargetProperty(uint16_t length);
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800300
301 struct ReturnData {
302 uint32_t displayRequests = 0;
303
304 std::vector<Layer> changedLayers;
305 std::vector<IComposerClient::Composition> compositionTypes;
306
307 std::vector<Layer> requestedLayers;
308 std::vector<uint32_t> requestMasks;
309
310 int presentFence = -1;
311
312 std::vector<Layer> releasedLayers;
313 std::vector<int> releaseFences;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700314
315 uint32_t presentOrValidateState;
Peiyong Linafa0f572020-01-13 16:35:02 -0800316
317 // Composer 2.4 implementation can return a client target property
318 // structure to indicate the client target properties that hardware
319 // composer requests. The composer client must change the client target
320 // properties to match this request.
321 IComposerClient::ClientTargetProperty clientTargetProperty{PixelFormat::RGBA_8888,
322 Dataspace::UNKNOWN};
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800323 };
324
325 std::vector<CommandError> mErrors;
326 std::unordered_map<Display, ReturnData> mReturnData;
327
328 // When SELECT_DISPLAY is parsed, this is updated to point to the
329 // display's return data in mReturnData. We use it to avoid repeated
330 // map lookups.
331 ReturnData* mCurrentReturnData;
332};
333
Ady Abrahame7385f72021-09-05 00:54:25 -0700334class AidlCommandReader : public AidlCommandReaderBase {
335public:
336 ~AidlCommandReader();
337
338 // Parse and execute commands from the command queue. The commands are
339 // actually return values from the server and will be saved in ReturnData.
340 int parse();
341
342 // Get and clear saved errors.
343 struct CommandError {
344 uint32_t location;
345 Error error;
346 };
347 std::vector<CommandError> takeErrors();
348
349 bool hasChanges(Display display, uint32_t* outNumChangedCompositionTypes,
350 uint32_t* outNumLayerRequestMasks) const;
351
352 // Get and clear saved changed composition types.
353 void takeChangedCompositionTypes(Display display, std::vector<Layer>* outLayers,
354 std::vector<IComposerClient::Composition>* outTypes);
355
356 // Get and clear saved display requests.
357 void takeDisplayRequests(Display display, uint32_t* outDisplayRequestMask,
358 std::vector<Layer>* outLayers,
359 std::vector<uint32_t>* outLayerRequestMasks);
360
361 // Get and clear saved release fences.
362 void takeReleaseFences(Display display, std::vector<Layer>* outLayers,
363 std::vector<int>* outReleaseFences);
364
365 // Get and clear saved present fence.
366 void takePresentFence(Display display, int* outPresentFence);
367
368 // Get what stage succeeded during PresentOrValidate: Present or Validate
369 void takePresentOrValidateStage(Display display, uint32_t* state);
370
371 // Get the client target properties requested by hardware composer.
372 void takeClientTargetProperty(Display display,
373 IComposerClient::ClientTargetProperty* outClientTargetProperty);
374
375private:
376 void resetData();
377
378 bool parseSelectDisplay(uint16_t length);
379 bool parseSetError(uint16_t length);
380 bool parseSetChangedCompositionTypes(uint16_t length);
381 bool parseSetDisplayRequests(uint16_t length);
382 bool parseSetPresentFence(uint16_t length);
383 bool parseSetReleaseFences(uint16_t length);
384 bool parseSetPresentOrValidateDisplayResult(uint16_t length);
385 bool parseSetClientTargetProperty(uint16_t length);
386
387 struct ReturnData {
388 uint32_t displayRequests = 0;
389
390 std::vector<Layer> changedLayers;
391 std::vector<IComposerClient::Composition> compositionTypes;
392
393 std::vector<Layer> requestedLayers;
394 std::vector<uint32_t> requestMasks;
395
396 int presentFence = -1;
397
398 std::vector<Layer> releasedLayers;
399 std::vector<int> releaseFences;
400
401 uint32_t presentOrValidateState;
402
403 // Composer 2.4 implementation can return a client target property
404 // structure to indicate the client target properties that hardware
405 // composer requests. The composer client must change the client target
406 // properties to match this request.
407 IComposerClient::ClientTargetProperty clientTargetProperty{PixelFormat::RGBA_8888,
408 Dataspace::UNKNOWN};
409 };
410
411 std::vector<CommandError> mErrors;
412 std::unordered_map<Display, ReturnData> mReturnData;
413
414 // When SELECT_DISPLAY is parsed, this is updated to point to the
415 // display's return data in mReturnData. We use it to avoid repeated
416 // map lookups.
417 ReturnData* mCurrentReturnData;
418};
419
Chia-I Wuaab99f52016-10-05 12:59:58 +0800420// Composer is a wrapper to IComposer, a proxy to server-side composer.
Lloyd Piquea822d522017-12-20 16:42:57 -0800421class Composer final : public Hwc2::Composer {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800422public:
Chih-Hung Hsieh22749042018-12-20 15:50:39 -0800423 explicit Composer(const std::string& serviceName);
Lloyd Piquea822d522017-12-20 16:42:57 -0800424 ~Composer() override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800425
Lloyd Piquea822d522017-12-20 16:42:57 -0800426 std::vector<IComposer::Capability> getCapabilities() override;
427 std::string dumpDebugInfo() override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800428
Lloyd Piquea822d522017-12-20 16:42:57 -0800429 void registerCallback(const sp<IComposerCallback>& callback) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800430
Steven Thomas0af4b9f2017-04-26 14:34:01 -0700431 // Reset all pending commands in the command buffer. Useful if you want to
432 // skip a frame but have already queued some commands.
Lloyd Piquea822d522017-12-20 16:42:57 -0800433 void resetCommands() override;
Steven Thomas0af4b9f2017-04-26 14:34:01 -0700434
Chia-I Wuae5a6b82017-10-10 09:09:22 -0700435 // Explicitly flush all pending commands in the command buffer.
Lloyd Piquea822d522017-12-20 16:42:57 -0800436 Error executeCommands() override;
Chia-I Wuae5a6b82017-10-10 09:09:22 -0700437
Lloyd Piquea822d522017-12-20 16:42:57 -0800438 uint32_t getMaxVirtualDisplayCount() override;
Lloyd Piquea822d522017-12-20 16:42:57 -0800439 Error createVirtualDisplay(uint32_t width, uint32_t height, PixelFormat* format,
Dominik Laskowski263eec42021-07-21 23:13:24 -0700440 Display* outDisplay) override;
Lloyd Piquea822d522017-12-20 16:42:57 -0800441 Error destroyVirtualDisplay(Display display) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800442
Lloyd Piquea822d522017-12-20 16:42:57 -0800443 Error acceptDisplayChanges(Display display) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800444
Lloyd Piquea822d522017-12-20 16:42:57 -0800445 Error createLayer(Display display, Layer* outLayer) override;
446 Error destroyLayer(Display display, Layer layer) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800447
Lloyd Piquea822d522017-12-20 16:42:57 -0800448 Error getActiveConfig(Display display, Config* outConfig) override;
449 Error getChangedCompositionTypes(Display display, std::vector<Layer>* outLayers,
450 std::vector<IComposerClient::Composition>* outTypes) override;
451 Error getColorModes(Display display, std::vector<ColorMode>* outModes) override;
452 Error getDisplayAttribute(Display display, Config config, IComposerClient::Attribute attribute,
453 int32_t* outValue) override;
Chia-I Wu67e376d2016-12-19 11:36:22 +0800454 Error getDisplayConfigs(Display display, std::vector<Config>* outConfigs);
Lloyd Piquea822d522017-12-20 16:42:57 -0800455 Error getDisplayName(Display display, std::string* outName) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800456
Chia-I Wu67e376d2016-12-19 11:36:22 +0800457 Error getDisplayRequests(Display display, uint32_t* outDisplayRequestMask,
Lloyd Piquea822d522017-12-20 16:42:57 -0800458 std::vector<Layer>* outLayers,
459 std::vector<uint32_t>* outLayerRequestMasks) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800460
Lloyd Piquea822d522017-12-20 16:42:57 -0800461 Error getDozeSupport(Display display, bool* outSupport) override;
462 Error getHdrCapabilities(Display display, std::vector<Hdr>* outTypes, float* outMaxLuminance,
463 float* outMaxAverageLuminance, float* outMinLuminance) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800464
Chia-I Wu67e376d2016-12-19 11:36:22 +0800465 Error getReleaseFences(Display display, std::vector<Layer>* outLayers,
Lloyd Piquea822d522017-12-20 16:42:57 -0800466 std::vector<int>* outReleaseFences) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800467
Lloyd Piquea822d522017-12-20 16:42:57 -0800468 Error presentDisplay(Display display, int* outPresentFence) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800469
Lloyd Piquea822d522017-12-20 16:42:57 -0800470 Error setActiveConfig(Display display, Config config) override;
Chia-I Wu06d63de2017-01-04 14:58:51 +0800471
472 /*
473 * The composer caches client targets internally. When target is nullptr,
474 * the composer uses slot to look up the client target from its cache.
475 * When target is not nullptr, the cache is updated with the new target.
476 */
Lloyd Piquea822d522017-12-20 16:42:57 -0800477 Error setClientTarget(Display display, uint32_t slot, const sp<GraphicBuffer>& target,
478 int acquireFence, Dataspace dataspace,
479 const std::vector<IComposerClient::Rect>& damage) override;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700480 Error setColorMode(Display display, ColorMode mode, RenderIntent renderIntent) override;
Lloyd Piquea822d522017-12-20 16:42:57 -0800481 Error setColorTransform(Display display, const float* matrix, ColorTransform hint) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800482 Error setOutputBuffer(Display display, const native_handle_t* buffer,
Lloyd Piquea822d522017-12-20 16:42:57 -0800483 int releaseFence) override;
484 Error setPowerMode(Display display, IComposerClient::PowerMode mode) override;
485 Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled) override;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800486
Lloyd Piquea822d522017-12-20 16:42:57 -0800487 Error setClientTargetSlotCount(Display display) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800488
Chia-I Wu67e376d2016-12-19 11:36:22 +0800489 Error validateDisplay(Display display, uint32_t* outNumTypes,
Lloyd Piquea822d522017-12-20 16:42:57 -0800490 uint32_t* outNumRequests) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800491
Lloyd Piquea822d522017-12-20 16:42:57 -0800492 Error presentOrValidateDisplay(Display display, uint32_t* outNumTypes, uint32_t* outNumRequests,
493 int* outPresentFence, uint32_t* state) override;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700494
Lloyd Piquea822d522017-12-20 16:42:57 -0800495 Error setCursorPosition(Display display, Layer layer, int32_t x, int32_t y) override;
Chia-I Wu06d63de2017-01-04 14:58:51 +0800496 /* see setClientTarget for the purpose of slot */
497 Error setLayerBuffer(Display display, Layer layer, uint32_t slot,
Lloyd Piquea822d522017-12-20 16:42:57 -0800498 const sp<GraphicBuffer>& buffer, int acquireFence) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800499 Error setLayerSurfaceDamage(Display display, Layer layer,
Lloyd Piquea822d522017-12-20 16:42:57 -0800500 const std::vector<IComposerClient::Rect>& damage) override;
501 Error setLayerBlendMode(Display display, Layer layer, IComposerClient::BlendMode mode) override;
502 Error setLayerColor(Display display, Layer layer, const IComposerClient::Color& color) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800503 Error setLayerCompositionType(Display display, Layer layer,
Lloyd Piquea822d522017-12-20 16:42:57 -0800504 IComposerClient::Composition type) override;
505 Error setLayerDataspace(Display display, Layer layer, Dataspace dataspace) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800506 Error setLayerDisplayFrame(Display display, Layer layer,
Lloyd Piquea822d522017-12-20 16:42:57 -0800507 const IComposerClient::Rect& frame) override;
508 Error setLayerPlaneAlpha(Display display, Layer layer, float alpha) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800509 Error setLayerSidebandStream(Display display, Layer layer,
Lloyd Piquea822d522017-12-20 16:42:57 -0800510 const native_handle_t* stream) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800511 Error setLayerSourceCrop(Display display, Layer layer,
Lloyd Piquea822d522017-12-20 16:42:57 -0800512 const IComposerClient::FRect& crop) override;
513 Error setLayerTransform(Display display, Layer layer, Transform transform) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800514 Error setLayerVisibleRegion(Display display, Layer layer,
Lloyd Piquea822d522017-12-20 16:42:57 -0800515 const std::vector<IComposerClient::Rect>& visible) override;
516 Error setLayerZOrder(Display display, Layer layer, uint32_t z) override;
Lloyd Piquea822d522017-12-20 16:42:57 -0800517
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700518 // Composer HAL 2.2
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700519 Error setLayerPerFrameMetadata(
520 Display display, Layer layer,
521 const std::vector<IComposerClient::PerFrameMetadata>& perFrameMetadatas) override;
Chia-I Wud7e01d72018-06-21 13:39:09 +0800522 std::vector<IComposerClient::PerFrameMetadataKey> getPerFrameMetadataKeys(
523 Display display) override;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700524 Error getRenderIntents(Display display, ColorMode colorMode,
525 std::vector<RenderIntent>* outRenderIntents) override;
526 Error getDataspaceSaturationMatrix(Dataspace dataspace, mat4* outMatrix) override;
527
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700528 // Composer HAL 2.3
529 Error getDisplayIdentificationData(Display display, uint8_t* outPort,
530 std::vector<uint8_t>* outData) override;
Peiyong Lin698147a2018-09-14 13:27:18 -0700531 Error setLayerColorTransform(Display display, Layer layer, const float* matrix) override;
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700532 Error getDisplayedContentSamplingAttributes(Display display, PixelFormat* outFormat,
533 Dataspace* outDataspace,
534 uint8_t* outComponentMask) override;
Kevin DuBois74e53772018-11-19 10:52:38 -0800535 Error setDisplayContentSamplingEnabled(Display display, bool enabled, uint8_t componentMask,
536 uint64_t maxFrames) override;
Kevin DuBois1d4249a2018-08-29 10:45:14 -0700537 Error getDisplayedContentSample(Display display, uint64_t maxFrames, uint64_t timestamp,
538 DisplayedFrameStats* outStats) override;
Valerie Haue9e843a2018-12-18 13:39:23 -0800539 Error setLayerPerFrameMetadataBlobs(
540 Display display, Layer layer,
541 const std::vector<IComposerClient::PerFrameMetadataBlob>& metadata) override;
Dan Gittik57e63c52019-01-18 16:37:54 +0000542 Error setDisplayBrightness(Display display, float brightness) override;
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700543
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -0700544 // Composer HAL 2.4
Ady Abraham7159f572019-10-11 11:10:18 -0700545 bool isVsyncPeriodSwitchSupported() override { return mClient_2_4 != nullptr; }
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -0700546 Error getDisplayCapabilities(Display display,
547 std::vector<DisplayCapability>* outCapabilities) override;
Ady Abraham7159f572019-10-11 11:10:18 -0700548 V2_4::Error getDisplayConnectionType(Display display,
549 IComposerClient::DisplayConnectionType* outType) override;
550 V2_4::Error getDisplayVsyncPeriod(Display display, VsyncPeriodNanos* outVsyncPeriod) override;
551 V2_4::Error setActiveConfigWithConstraints(
552 Display display, Config config,
553 const IComposerClient::VsyncPeriodChangeConstraints& vsyncPeriodChangeConstraints,
554 VsyncPeriodChangeTimeline* outTimeline) override;
Galia Peycheva5492cb52019-10-30 14:13:16 +0100555 V2_4::Error setAutoLowLatencyMode(Display displayId, bool on) override;
556 V2_4::Error getSupportedContentTypes(
557 Display displayId,
558 std::vector<IComposerClient::ContentType>* outSupportedContentTypes) override;
559 V2_4::Error setContentType(Display displayId,
560 IComposerClient::ContentType contentType) override;
Dan Stoza18d48cb2019-10-21 15:39:24 -0700561 V2_4::Error setLayerGenericMetadata(Display display, Layer layer, const std::string& key,
562 bool mandatory, const std::vector<uint8_t>& value) override;
563 V2_4::Error getLayerGenericMetadataKeys(
564 std::vector<IComposerClient::LayerGenericMetadataKey>* outKeys) override;
Peiyong Lindfc3f7c2020-05-07 20:15:50 -0700565 Error getClientTargetProperty(
566 Display display,
567 IComposerClient::ClientTargetProperty* outClientTargetProperty) override;
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -0700568
Chia-I Wuaab99f52016-10-05 12:59:58 +0800569private:
mamik94e91f62019-08-19 09:11:33 -0700570 class CommandWriter : public CommandWriterBase {
571 public:
572 explicit CommandWriter(uint32_t initialMaxSize) : CommandWriterBase(initialMaxSize) {}
573 ~CommandWriter() override {}
574 };
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -0500575
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800576 // Many public functions above simply write a command into the command
577 // queue to batch the calls. validateDisplay and presentDisplay will call
578 // this function to execute the command queue.
579 Error execute();
580
Dominik Laskowski6231aaf2018-04-02 17:10:23 -0700581 sp<V2_1::IComposer> mComposer;
582
583 sp<V2_1::IComposerClient> mClient;
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700584 sp<V2_2::IComposerClient> mClient_2_2;
Dominik Laskowski25a4e7d2019-09-20 14:50:10 -0700585 sp<V2_3::IComposerClient> mClient_2_3;
586 sp<IComposerClient> mClient_2_4;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800587
588 // 64KiB minus a small space for metadata such as read/write pointers
589 static constexpr size_t kWriterInitialSize =
590 64 * 1024 / sizeof(uint32_t) - 16;
Alec Mourie7cc1c22021-04-27 15:23:26 -0700591 // Max number of buffers that may be cached for a given layer
592 // We obtain this number by:
593 // 1. Tightly coupling this cache to the max size of BufferQueue
594 // 2. Adding an additional slot for the layer caching feature in SurfaceFlinger (see: Planner.h)
595 static const constexpr uint32_t kMaxLayerBufferCount = BufferQueue::NUM_BUFFER_SLOTS + 1;
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -0500596 CommandWriter mWriter;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800597 CommandReader mReader;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800598};
599
Ady Abrahame7385f72021-09-05 00:54:25 -0700600// Composer is a wrapper to IComposer, a proxy to server-side composer.
601class AidlComposer final : public Hwc2::Composer {
602public:
603 explicit AidlComposer(const std::string& serviceName);
604 ~AidlComposer() override;
605
606 std::vector<IComposer::Capability> getCapabilities() override;
607 std::string dumpDebugInfo() override;
608
609 void registerCallback(const sp<IComposerCallback>& callback) override;
610
611 // Reset all pending commands in the command buffer. Useful if you want to
612 // skip a frame but have already queued some commands.
613 void resetCommands() override;
614
615 // Explicitly flush all pending commands in the command buffer.
616 Error executeCommands() override;
617
618 uint32_t getMaxVirtualDisplayCount() override;
619 Error createVirtualDisplay(uint32_t width, uint32_t height, PixelFormat* format,
620 Display* outDisplay) override;
621 Error destroyVirtualDisplay(Display display) override;
622
623 Error acceptDisplayChanges(Display display) override;
624
625 Error createLayer(Display display, Layer* outLayer) override;
626 Error destroyLayer(Display display, Layer layer) override;
627
628 Error getActiveConfig(Display display, Config* outConfig) override;
629 Error getChangedCompositionTypes(Display display, std::vector<Layer>* outLayers,
630 std::vector<IComposerClient::Composition>* outTypes) override;
631 Error getColorModes(Display display, std::vector<ColorMode>* outModes) override;
632 Error getDisplayAttribute(Display display, Config config, IComposerClient::Attribute attribute,
633 int32_t* outValue) override;
634 Error getDisplayConfigs(Display display, std::vector<Config>* outConfigs);
635 Error getDisplayName(Display display, std::string* outName) override;
636
637 Error getDisplayRequests(Display display, uint32_t* outDisplayRequestMask,
638 std::vector<Layer>* outLayers,
639 std::vector<uint32_t>* outLayerRequestMasks) override;
640
641 Error getDozeSupport(Display display, bool* outSupport) override;
642 Error getHdrCapabilities(Display display, std::vector<Hdr>* outTypes, float* outMaxLuminance,
643 float* outMaxAverageLuminance, float* outMinLuminance) override;
644
645 Error getReleaseFences(Display display, std::vector<Layer>* outLayers,
646 std::vector<int>* outReleaseFences) override;
647
648 Error presentDisplay(Display display, int* outPresentFence) override;
649
650 Error setActiveConfig(Display display, Config config) override;
651
652 /*
653 * The composer caches client targets internally. When target is nullptr,
654 * the composer uses slot to look up the client target from its cache.
655 * When target is not nullptr, the cache is updated with the new target.
656 */
657 Error setClientTarget(Display display, uint32_t slot, const sp<GraphicBuffer>& target,
658 int acquireFence, Dataspace dataspace,
659 const std::vector<IComposerClient::Rect>& damage) override;
660 Error setColorMode(Display display, ColorMode mode, RenderIntent renderIntent) override;
661 Error setColorTransform(Display display, const float* matrix, ColorTransform hint) override;
662 Error setOutputBuffer(Display display, const native_handle_t* buffer,
663 int releaseFence) override;
664 Error setPowerMode(Display display, IComposerClient::PowerMode mode) override;
665 Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled) override;
666
667 Error setClientTargetSlotCount(Display display) override;
668
669 Error validateDisplay(Display display, uint32_t* outNumTypes,
670 uint32_t* outNumRequests) override;
671
672 Error presentOrValidateDisplay(Display display, uint32_t* outNumTypes, uint32_t* outNumRequests,
673 int* outPresentFence, uint32_t* state) override;
674
675 Error setCursorPosition(Display display, Layer layer, int32_t x, int32_t y) override;
676 /* see setClientTarget for the purpose of slot */
677 Error setLayerBuffer(Display display, Layer layer, uint32_t slot,
678 const sp<GraphicBuffer>& buffer, int acquireFence) override;
679 Error setLayerSurfaceDamage(Display display, Layer layer,
680 const std::vector<IComposerClient::Rect>& damage) override;
681 Error setLayerBlendMode(Display display, Layer layer, IComposerClient::BlendMode mode) override;
682 Error setLayerColor(Display display, Layer layer, const IComposerClient::Color& color) override;
683 Error setLayerCompositionType(Display display, Layer layer,
684 IComposerClient::Composition type) override;
685 Error setLayerDataspace(Display display, Layer layer, Dataspace dataspace) override;
686 Error setLayerDisplayFrame(Display display, Layer layer,
687 const IComposerClient::Rect& frame) override;
688 Error setLayerPlaneAlpha(Display display, Layer layer, float alpha) override;
689 Error setLayerSidebandStream(Display display, Layer layer,
690 const native_handle_t* stream) override;
691 Error setLayerSourceCrop(Display display, Layer layer,
692 const IComposerClient::FRect& crop) override;
693 Error setLayerTransform(Display display, Layer layer, Transform transform) override;
694 Error setLayerVisibleRegion(Display display, Layer layer,
695 const std::vector<IComposerClient::Rect>& visible) override;
696 Error setLayerZOrder(Display display, Layer layer, uint32_t z) override;
697
698 // Composer HAL 2.2
699 Error setLayerPerFrameMetadata(
700 Display display, Layer layer,
701 const std::vector<IComposerClient::PerFrameMetadata>& perFrameMetadatas) override;
702 std::vector<IComposerClient::PerFrameMetadataKey> getPerFrameMetadataKeys(
703 Display display) override;
704 Error getRenderIntents(Display display, ColorMode colorMode,
705 std::vector<RenderIntent>* outRenderIntents) override;
706 Error getDataspaceSaturationMatrix(Dataspace dataspace, mat4* outMatrix) override;
707
708 // Composer HAL 2.3
709 Error getDisplayIdentificationData(Display display, uint8_t* outPort,
710 std::vector<uint8_t>* outData) override;
711 Error setLayerColorTransform(Display display, Layer layer, const float* matrix) override;
712 Error getDisplayedContentSamplingAttributes(Display display, PixelFormat* outFormat,
713 Dataspace* outDataspace,
714 uint8_t* outComponentMask) override;
715 Error setDisplayContentSamplingEnabled(Display display, bool enabled, uint8_t componentMask,
716 uint64_t maxFrames) override;
717 Error getDisplayedContentSample(Display display, uint64_t maxFrames, uint64_t timestamp,
718 DisplayedFrameStats* outStats) override;
719 Error setLayerPerFrameMetadataBlobs(
720 Display display, Layer layer,
721 const std::vector<IComposerClient::PerFrameMetadataBlob>& metadata) override;
722 Error setDisplayBrightness(Display display, float brightness) override;
723
724 // Composer HAL 2.4
725 bool isVsyncPeriodSwitchSupported() override { return true; }
726 Error getDisplayCapabilities(Display display,
727 std::vector<DisplayCapability>* outCapabilities) override;
728 V2_4::Error getDisplayConnectionType(Display display,
729 IComposerClient::DisplayConnectionType* outType) override;
730 V2_4::Error getDisplayVsyncPeriod(Display display, VsyncPeriodNanos* outVsyncPeriod) override;
731 V2_4::Error setActiveConfigWithConstraints(
732 Display display, Config config,
733 const IComposerClient::VsyncPeriodChangeConstraints& vsyncPeriodChangeConstraints,
734 VsyncPeriodChangeTimeline* outTimeline) override;
735 V2_4::Error setAutoLowLatencyMode(Display displayId, bool on) override;
736 V2_4::Error getSupportedContentTypes(
737 Display displayId,
738 std::vector<IComposerClient::ContentType>* outSupportedContentTypes) override;
739 V2_4::Error setContentType(Display displayId,
740 IComposerClient::ContentType contentType) override;
741 V2_4::Error setLayerGenericMetadata(Display display, Layer layer, const std::string& key,
742 bool mandatory, const std::vector<uint8_t>& value) override;
743 V2_4::Error getLayerGenericMetadataKeys(
744 std::vector<IComposerClient::LayerGenericMetadataKey>* outKeys) override;
745 Error getClientTargetProperty(
746 Display display,
747 IComposerClient::ClientTargetProperty* outClientTargetProperty) override;
748
749private:
750 class AidlCommandWriter : public AidlCommandWriterBase {
751 public:
752 explicit AidlCommandWriter(uint32_t initialMaxSize)
753 : AidlCommandWriterBase(initialMaxSize) {}
754 ~AidlCommandWriter() override {}
755 };
756
757 // Many public functions above simply write a command into the command
758 // queue to batch the calls. validateDisplay and presentDisplay will call
759 // this function to execute the command queue.
760 Error execute();
761
762 // 64KiB minus a small space for metadata such as read/write pointers
763 static constexpr size_t kWriterInitialSize = 64 * 1024 / sizeof(uint32_t) - 16;
764 // Max number of buffers that may be cached for a given layer
765 // We obtain this number by:
766 // 1. Tightly coupling this cache to the max size of BufferQueue
767 // 2. Adding an additional slot for the layer caching feature in SurfaceFlinger (see: Planner.h)
768 static const constexpr uint32_t kMaxLayerBufferCount = BufferQueue::NUM_BUFFER_SLOTS + 1;
769 AidlCommandWriter mWriter;
770 AidlCommandReader mReader;
771
772 // Aidl interface
773 using AidlIComposer = aidl::android::hardware::graphics::composer3::IComposer;
774 using AidlIComposerClient = aidl::android::hardware::graphics::composer3::IComposerClient;
775 std::shared_ptr<AidlIComposer> mAidlComposer;
776 std::shared_ptr<AidlIComposerClient> mAidlComposerClient;
777 std::shared_ptr<AidlIComposerCallbackWrapper> mAidlComposerCallback;
778};
779
Lloyd Piquea822d522017-12-20 16:42:57 -0800780} // namespace impl
781
Chia-I Wuaab99f52016-10-05 12:59:58 +0800782} // namespace Hwc2
783
784} // namespace android
785
786#endif // ANDROID_SF_COMPOSER_HAL_H