blob: 61af34892bf2819bf8cf694216513ec3e0bd1383 [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>
Chia-I Wuaab99f52016-10-05 12:59:58 +080021#include <string>
Chia-I Wucd8d7f02016-11-16 11:02:31 +080022#include <unordered_map>
23#include <utility>
Chia-I Wuaab99f52016-10-05 12:59:58 +080024#include <vector>
25
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -040026#include <android/frameworks/vr/composer/1.0/IVrComposerClient.h>
Peiyong Lin34beb7a2018-03-28 11:57:12 -070027#include <android/hardware/graphics/common/1.1/types.h>
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -070028#include <android/hardware/graphics/composer/2.3/IComposer.h>
29#include <android/hardware/graphics/composer/2.3/IComposerClient.h>
Peiyong Lin698147a2018-09-14 13:27:18 -070030#include <composer-command-buffer/2.3/ComposerCommandBuffer.h>
Courtney Goeltzenleuchterf9c98e52018-02-12 07:23:17 -070031#include <gui/HdrMetadata.h>
Peiyong Lin0e7a7912018-04-05 14:36:36 -070032#include <math/mat4.h>
Lloyd Piqued0094aa2017-12-20 16:43:28 -080033#include <ui/GraphicBuffer.h>
Chia-I Wuaab99f52016-10-05 12:59:58 +080034#include <utils/StrongPointer.h>
35
36namespace android {
37
38namespace Hwc2 {
39
Dominik Laskowski6231aaf2018-04-02 17:10:23 -070040using frameworks::vr::composer::V1_0::IVrComposerClient;
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -040041
Dominik Laskowski6231aaf2018-04-02 17:10:23 -070042namespace types = hardware::graphics::common;
Chia-I Wuaab99f52016-10-05 12:59:58 +080043
Dominik Laskowski6231aaf2018-04-02 17:10:23 -070044namespace V2_1 = hardware::graphics::composer::V2_1;
45namespace V2_2 = hardware::graphics::composer::V2_2;
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -070046namespace V2_3 = hardware::graphics::composer::V2_3;
Chia-I Wuaab99f52016-10-05 12:59:58 +080047
Dominik Laskowski6231aaf2018-04-02 17:10:23 -070048using types::V1_0::ColorTransform;
49using types::V1_0::Hdr;
50using types::V1_0::Transform;
Dominik Laskowski6231aaf2018-04-02 17:10:23 -070051using types::V1_1::PixelFormat;
52using types::V1_1::RenderIntent;
Valerie Hau9758ae02018-10-09 16:05:09 -070053using types::V1_2::ColorMode;
54using types::V1_2::Dataspace;
Dominik Laskowski6231aaf2018-04-02 17:10:23 -070055using V2_1::Config;
56using V2_1::Display;
57using V2_1::Error;
58using V2_1::IComposerCallback;
59using V2_1::Layer;
Peiyong Lin698147a2018-09-14 13:27:18 -070060using V2_3::CommandReaderBase;
61using V2_3::CommandWriterBase;
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -070062using V2_3::IComposer;
63using V2_3::IComposerClient;
Peiyong Lined531a32018-10-26 18:27:56 -070064using DisplayCapability = IComposerClient::DisplayCapability;
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -070065using PerFrameMetadata = IComposerClient::PerFrameMetadata;
66using PerFrameMetadataKey = IComposerClient::PerFrameMetadataKey;
67
Lloyd Piquea822d522017-12-20 16:42:57 -080068class Composer {
69public:
70 virtual ~Composer() = 0;
71
72 virtual std::vector<IComposer::Capability> getCapabilities() = 0;
73 virtual std::string dumpDebugInfo() = 0;
74
75 virtual void registerCallback(const sp<IComposerCallback>& callback) = 0;
76
77 // Returns true if the connected composer service is running in a remote
78 // process, false otherwise. This will return false if the service is
79 // configured in passthrough mode, for example.
80 virtual bool isRemote() = 0;
81
82 // Reset all pending commands in the command buffer. Useful if you want to
83 // skip a frame but have already queued some commands.
84 virtual void resetCommands() = 0;
85
86 // Explicitly flush all pending commands in the command buffer.
87 virtual Error executeCommands() = 0;
88
89 virtual uint32_t getMaxVirtualDisplayCount() = 0;
90 virtual bool isUsingVrComposer() const = 0;
91 virtual Error createVirtualDisplay(uint32_t width, uint32_t height, PixelFormat* format,
92 Display* outDisplay) = 0;
93 virtual Error destroyVirtualDisplay(Display display) = 0;
94
95 virtual Error acceptDisplayChanges(Display display) = 0;
96
97 virtual Error createLayer(Display display, Layer* outLayer) = 0;
98 virtual Error destroyLayer(Display display, Layer layer) = 0;
99
100 virtual Error getActiveConfig(Display display, Config* outConfig) = 0;
101 virtual Error getChangedCompositionTypes(
102 Display display, std::vector<Layer>* outLayers,
103 std::vector<IComposerClient::Composition>* outTypes) = 0;
104 virtual Error getColorModes(Display display, std::vector<ColorMode>* outModes) = 0;
105 virtual Error getDisplayAttribute(Display display, Config config,
106 IComposerClient::Attribute attribute, int32_t* outValue) = 0;
107 virtual Error getDisplayConfigs(Display display, std::vector<Config>* outConfigs) = 0;
108 virtual Error getDisplayName(Display display, std::string* outName) = 0;
109
110 virtual Error getDisplayRequests(Display display, uint32_t* outDisplayRequestMask,
111 std::vector<Layer>* outLayers,
112 std::vector<uint32_t>* outLayerRequestMasks) = 0;
113
114 virtual Error getDisplayType(Display display, IComposerClient::DisplayType* outType) = 0;
115 virtual Error getDozeSupport(Display display, bool* outSupport) = 0;
116 virtual Error getHdrCapabilities(Display display, std::vector<Hdr>* outTypes,
117 float* outMaxLuminance, float* outMaxAverageLuminance,
118 float* outMinLuminance) = 0;
119
120 virtual Error getReleaseFences(Display display, std::vector<Layer>* outLayers,
121 std::vector<int>* outReleaseFences) = 0;
122
123 virtual Error presentDisplay(Display display, int* outPresentFence) = 0;
124
125 virtual Error setActiveConfig(Display display, Config config) = 0;
126
127 /*
128 * The composer caches client targets internally. When target is nullptr,
129 * the composer uses slot to look up the client target from its cache.
130 * When target is not nullptr, the cache is updated with the new target.
131 */
132 virtual Error setClientTarget(Display display, uint32_t slot, const sp<GraphicBuffer>& target,
133 int acquireFence, Dataspace dataspace,
134 const std::vector<IComposerClient::Rect>& damage) = 0;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700135 virtual Error setColorMode(Display display, ColorMode mode, RenderIntent renderIntent) = 0;
Lloyd Piquea822d522017-12-20 16:42:57 -0800136 virtual Error setColorTransform(Display display, const float* matrix, ColorTransform hint) = 0;
137 virtual Error setOutputBuffer(Display display, const native_handle_t* buffer,
138 int releaseFence) = 0;
139 virtual Error setPowerMode(Display display, IComposerClient::PowerMode mode) = 0;
140 virtual Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled) = 0;
141
142 virtual Error setClientTargetSlotCount(Display display) = 0;
143
144 virtual Error validateDisplay(Display display, uint32_t* outNumTypes,
145 uint32_t* outNumRequests) = 0;
146
147 virtual Error presentOrValidateDisplay(Display display, uint32_t* outNumTypes,
148 uint32_t* outNumRequests, int* outPresentFence,
149 uint32_t* state) = 0;
150
151 virtual Error setCursorPosition(Display display, Layer layer, int32_t x, int32_t y) = 0;
152 /* see setClientTarget for the purpose of slot */
153 virtual Error setLayerBuffer(Display display, Layer layer, uint32_t slot,
154 const sp<GraphicBuffer>& buffer, int acquireFence) = 0;
155 virtual Error setLayerSurfaceDamage(Display display, Layer layer,
156 const std::vector<IComposerClient::Rect>& damage) = 0;
157 virtual Error setLayerBlendMode(Display display, Layer layer,
158 IComposerClient::BlendMode mode) = 0;
159 virtual Error setLayerColor(Display display, Layer layer,
160 const IComposerClient::Color& color) = 0;
161 virtual Error setLayerCompositionType(Display display, Layer layer,
162 IComposerClient::Composition type) = 0;
163 virtual Error setLayerDataspace(Display display, Layer layer, Dataspace dataspace) = 0;
164 virtual Error setLayerDisplayFrame(Display display, Layer layer,
165 const IComposerClient::Rect& frame) = 0;
166 virtual Error setLayerPlaneAlpha(Display display, Layer layer, float alpha) = 0;
167 virtual Error setLayerSidebandStream(Display display, Layer layer,
168 const native_handle_t* stream) = 0;
169 virtual Error setLayerSourceCrop(Display display, Layer layer,
170 const IComposerClient::FRect& crop) = 0;
171 virtual Error setLayerTransform(Display display, Layer layer, Transform transform) = 0;
172 virtual Error setLayerVisibleRegion(Display display, Layer layer,
173 const std::vector<IComposerClient::Rect>& visible) = 0;
174 virtual Error setLayerZOrder(Display display, Layer layer, uint32_t z) = 0;
175 virtual Error setLayerInfo(Display display, Layer layer, uint32_t type, uint32_t appId) = 0;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700176
177 // Composer HAL 2.2
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700178 virtual Error setLayerPerFrameMetadata(
179 Display display, Layer layer,
180 const std::vector<IComposerClient::PerFrameMetadata>& perFrameMetadatas) = 0;
Chia-I Wud7e01d72018-06-21 13:39:09 +0800181 virtual std::vector<IComposerClient::PerFrameMetadataKey> getPerFrameMetadataKeys(
182 Display display) = 0;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700183 virtual Error getRenderIntents(Display display, ColorMode colorMode,
184 std::vector<RenderIntent>* outRenderIntents) = 0;
185 virtual Error getDataspaceSaturationMatrix(Dataspace dataspace, mat4* outMatrix) = 0;
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700186
187 // Composer HAL 2.3
188 virtual Error getDisplayIdentificationData(Display display, uint8_t* outPort,
189 std::vector<uint8_t>* outData) = 0;
Peiyong Lin698147a2018-09-14 13:27:18 -0700190 virtual Error setLayerColorTransform(Display display, Layer layer,
191 const float* matrix) = 0;
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700192 virtual Error getDisplayedContentSamplingAttributes(Display display, PixelFormat* outFormat,
193 Dataspace* outDataspace,
194 uint8_t* outComponentMask) = 0;
Peiyong Lined531a32018-10-26 18:27:56 -0700195 virtual Error getDisplayCapabilities(Display display,
196 std::vector<DisplayCapability>* outCapabilities) = 0;
Lloyd Piquea822d522017-12-20 16:42:57 -0800197};
198
199namespace impl {
200
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800201class CommandReader : public CommandReaderBase {
202public:
203 ~CommandReader();
204
205 // Parse and execute commands from the command queue. The commands are
206 // actually return values from the server and will be saved in ReturnData.
207 Error parse();
208
209 // Get and clear saved errors.
210 struct CommandError {
211 uint32_t location;
212 Error error;
213 };
214 std::vector<CommandError> takeErrors();
215
Chia-I Wu67e376d2016-12-19 11:36:22 +0800216 bool hasChanges(Display display, uint32_t* outNumChangedCompositionTypes,
217 uint32_t* outNumLayerRequestMasks) const;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800218
219 // Get and clear saved changed composition types.
220 void takeChangedCompositionTypes(Display display,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800221 std::vector<Layer>* outLayers,
222 std::vector<IComposerClient::Composition>* outTypes);
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800223
224 // Get and clear saved display requests.
225 void takeDisplayRequests(Display display,
Chia-I Wu67e376d2016-12-19 11:36:22 +0800226 uint32_t* outDisplayRequestMask, std::vector<Layer>* outLayers,
227 std::vector<uint32_t>* outLayerRequestMasks);
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800228
229 // Get and clear saved release fences.
Chia-I Wu67e376d2016-12-19 11:36:22 +0800230 void takeReleaseFences(Display display, std::vector<Layer>* outLayers,
231 std::vector<int>* outReleaseFences);
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800232
233 // Get and clear saved present fence.
Chia-I Wu67e376d2016-12-19 11:36:22 +0800234 void takePresentFence(Display display, int* outPresentFence);
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800235
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700236 // Get what stage succeeded during PresentOrValidate: Present or Validate
237 void takePresentOrValidateStage(Display display, uint32_t * state);
238
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800239private:
240 void resetData();
241
242 bool parseSelectDisplay(uint16_t length);
243 bool parseSetError(uint16_t length);
244 bool parseSetChangedCompositionTypes(uint16_t length);
245 bool parseSetDisplayRequests(uint16_t length);
246 bool parseSetPresentFence(uint16_t length);
247 bool parseSetReleaseFences(uint16_t length);
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700248 bool parseSetPresentOrValidateDisplayResult(uint16_t length);
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800249
250 struct ReturnData {
251 uint32_t displayRequests = 0;
252
253 std::vector<Layer> changedLayers;
254 std::vector<IComposerClient::Composition> compositionTypes;
255
256 std::vector<Layer> requestedLayers;
257 std::vector<uint32_t> requestMasks;
258
259 int presentFence = -1;
260
261 std::vector<Layer> releasedLayers;
262 std::vector<int> releaseFences;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700263
264 uint32_t presentOrValidateState;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800265 };
266
267 std::vector<CommandError> mErrors;
268 std::unordered_map<Display, ReturnData> mReturnData;
269
270 // When SELECT_DISPLAY is parsed, this is updated to point to the
271 // display's return data in mReturnData. We use it to avoid repeated
272 // map lookups.
273 ReturnData* mCurrentReturnData;
274};
275
Chia-I Wuaab99f52016-10-05 12:59:58 +0800276// Composer is a wrapper to IComposer, a proxy to server-side composer.
Lloyd Piquea822d522017-12-20 16:42:57 -0800277class Composer final : public Hwc2::Composer {
Chia-I Wuaab99f52016-10-05 12:59:58 +0800278public:
Kalle Raitaa099a242017-01-11 11:17:29 -0800279 Composer(const std::string& serviceName);
Lloyd Piquea822d522017-12-20 16:42:57 -0800280 ~Composer() override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800281
Lloyd Piquea822d522017-12-20 16:42:57 -0800282 std::vector<IComposer::Capability> getCapabilities() override;
283 std::string dumpDebugInfo() override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800284
Lloyd Piquea822d522017-12-20 16:42:57 -0800285 void registerCallback(const sp<IComposerCallback>& callback) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800286
Steven Thomas94e35b92017-07-26 18:48:28 -0700287 // Returns true if the connected composer service is running in a remote
288 // process, false otherwise. This will return false if the service is
289 // configured in passthrough mode, for example.
Lloyd Piquea822d522017-12-20 16:42:57 -0800290 bool isRemote() override;
Steven Thomas94e35b92017-07-26 18:48:28 -0700291
Steven Thomas0af4b9f2017-04-26 14:34:01 -0700292 // Reset all pending commands in the command buffer. Useful if you want to
293 // skip a frame but have already queued some commands.
Lloyd Piquea822d522017-12-20 16:42:57 -0800294 void resetCommands() override;
Steven Thomas0af4b9f2017-04-26 14:34:01 -0700295
Chia-I Wuae5a6b82017-10-10 09:09:22 -0700296 // Explicitly flush all pending commands in the command buffer.
Lloyd Piquea822d522017-12-20 16:42:57 -0800297 Error executeCommands() override;
Chia-I Wuae5a6b82017-10-10 09:09:22 -0700298
Lloyd Piquea822d522017-12-20 16:42:57 -0800299 uint32_t getMaxVirtualDisplayCount() override;
300 bool isUsingVrComposer() const override { return mIsUsingVrComposer; }
301 Error createVirtualDisplay(uint32_t width, uint32_t height, PixelFormat* format,
302 Display* outDisplay) override;
303 Error destroyVirtualDisplay(Display display) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800304
Lloyd Piquea822d522017-12-20 16:42:57 -0800305 Error acceptDisplayChanges(Display display) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800306
Lloyd Piquea822d522017-12-20 16:42:57 -0800307 Error createLayer(Display display, Layer* outLayer) override;
308 Error destroyLayer(Display display, Layer layer) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800309
Lloyd Piquea822d522017-12-20 16:42:57 -0800310 Error getActiveConfig(Display display, Config* outConfig) override;
311 Error getChangedCompositionTypes(Display display, std::vector<Layer>* outLayers,
312 std::vector<IComposerClient::Composition>* outTypes) override;
313 Error getColorModes(Display display, std::vector<ColorMode>* outModes) override;
314 Error getDisplayAttribute(Display display, Config config, IComposerClient::Attribute attribute,
315 int32_t* outValue) override;
Chia-I Wu67e376d2016-12-19 11:36:22 +0800316 Error getDisplayConfigs(Display display, std::vector<Config>* outConfigs);
Lloyd Piquea822d522017-12-20 16:42:57 -0800317 Error getDisplayName(Display display, std::string* outName) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800318
Chia-I Wu67e376d2016-12-19 11:36:22 +0800319 Error getDisplayRequests(Display display, uint32_t* outDisplayRequestMask,
Lloyd Piquea822d522017-12-20 16:42:57 -0800320 std::vector<Layer>* outLayers,
321 std::vector<uint32_t>* outLayerRequestMasks) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800322
Lloyd Piquea822d522017-12-20 16:42:57 -0800323 Error getDisplayType(Display display, IComposerClient::DisplayType* outType) override;
324 Error getDozeSupport(Display display, bool* outSupport) override;
325 Error getHdrCapabilities(Display display, std::vector<Hdr>* outTypes, float* outMaxLuminance,
326 float* outMaxAverageLuminance, float* outMinLuminance) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800327
Chia-I Wu67e376d2016-12-19 11:36:22 +0800328 Error getReleaseFences(Display display, std::vector<Layer>* outLayers,
Lloyd Piquea822d522017-12-20 16:42:57 -0800329 std::vector<int>* outReleaseFences) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800330
Lloyd Piquea822d522017-12-20 16:42:57 -0800331 Error presentDisplay(Display display, int* outPresentFence) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800332
Lloyd Piquea822d522017-12-20 16:42:57 -0800333 Error setActiveConfig(Display display, Config config) override;
Chia-I Wu06d63de2017-01-04 14:58:51 +0800334
335 /*
336 * The composer caches client targets internally. When target is nullptr,
337 * the composer uses slot to look up the client target from its cache.
338 * When target is not nullptr, the cache is updated with the new target.
339 */
Lloyd Piquea822d522017-12-20 16:42:57 -0800340 Error setClientTarget(Display display, uint32_t slot, const sp<GraphicBuffer>& target,
341 int acquireFence, Dataspace dataspace,
342 const std::vector<IComposerClient::Rect>& damage) override;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700343 Error setColorMode(Display display, ColorMode mode, RenderIntent renderIntent) override;
Lloyd Piquea822d522017-12-20 16:42:57 -0800344 Error setColorTransform(Display display, const float* matrix, ColorTransform hint) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800345 Error setOutputBuffer(Display display, const native_handle_t* buffer,
Lloyd Piquea822d522017-12-20 16:42:57 -0800346 int releaseFence) override;
347 Error setPowerMode(Display display, IComposerClient::PowerMode mode) override;
348 Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled) override;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800349
Lloyd Piquea822d522017-12-20 16:42:57 -0800350 Error setClientTargetSlotCount(Display display) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800351
Chia-I Wu67e376d2016-12-19 11:36:22 +0800352 Error validateDisplay(Display display, uint32_t* outNumTypes,
Lloyd Piquea822d522017-12-20 16:42:57 -0800353 uint32_t* outNumRequests) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800354
Lloyd Piquea822d522017-12-20 16:42:57 -0800355 Error presentOrValidateDisplay(Display display, uint32_t* outNumTypes, uint32_t* outNumRequests,
356 int* outPresentFence, uint32_t* state) override;
Fabien Sanglard249c0ae2017-06-19 19:22:36 -0700357
Lloyd Piquea822d522017-12-20 16:42:57 -0800358 Error setCursorPosition(Display display, Layer layer, int32_t x, int32_t y) override;
Chia-I Wu06d63de2017-01-04 14:58:51 +0800359 /* see setClientTarget for the purpose of slot */
360 Error setLayerBuffer(Display display, Layer layer, uint32_t slot,
Lloyd Piquea822d522017-12-20 16:42:57 -0800361 const sp<GraphicBuffer>& buffer, int acquireFence) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800362 Error setLayerSurfaceDamage(Display display, Layer layer,
Lloyd Piquea822d522017-12-20 16:42:57 -0800363 const std::vector<IComposerClient::Rect>& damage) override;
364 Error setLayerBlendMode(Display display, Layer layer, IComposerClient::BlendMode mode) override;
365 Error setLayerColor(Display display, Layer layer, const IComposerClient::Color& color) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800366 Error setLayerCompositionType(Display display, Layer layer,
Lloyd Piquea822d522017-12-20 16:42:57 -0800367 IComposerClient::Composition type) override;
368 Error setLayerDataspace(Display display, Layer layer, Dataspace dataspace) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800369 Error setLayerDisplayFrame(Display display, Layer layer,
Lloyd Piquea822d522017-12-20 16:42:57 -0800370 const IComposerClient::Rect& frame) override;
371 Error setLayerPlaneAlpha(Display display, Layer layer, float alpha) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800372 Error setLayerSidebandStream(Display display, Layer layer,
Lloyd Piquea822d522017-12-20 16:42:57 -0800373 const native_handle_t* stream) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800374 Error setLayerSourceCrop(Display display, Layer layer,
Lloyd Piquea822d522017-12-20 16:42:57 -0800375 const IComposerClient::FRect& crop) override;
376 Error setLayerTransform(Display display, Layer layer, Transform transform) override;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800377 Error setLayerVisibleRegion(Display display, Layer layer,
Lloyd Piquea822d522017-12-20 16:42:57 -0800378 const std::vector<IComposerClient::Rect>& visible) override;
379 Error setLayerZOrder(Display display, Layer layer, uint32_t z) override;
380 Error setLayerInfo(Display display, Layer layer, uint32_t type, uint32_t appId) override;
381
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700382 // Composer HAL 2.2
Peiyong Lin0ac5f4e2018-04-19 22:06:34 -0700383 Error setLayerPerFrameMetadata(
384 Display display, Layer layer,
385 const std::vector<IComposerClient::PerFrameMetadata>& perFrameMetadatas) override;
Chia-I Wud7e01d72018-06-21 13:39:09 +0800386 std::vector<IComposerClient::PerFrameMetadataKey> getPerFrameMetadataKeys(
387 Display display) override;
Peiyong Lin0e7a7912018-04-05 14:36:36 -0700388 Error getRenderIntents(Display display, ColorMode colorMode,
389 std::vector<RenderIntent>* outRenderIntents) override;
390 Error getDataspaceSaturationMatrix(Dataspace dataspace, mat4* outMatrix) override;
391
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700392 // Composer HAL 2.3
393 Error getDisplayIdentificationData(Display display, uint8_t* outPort,
394 std::vector<uint8_t>* outData) override;
Peiyong Lin698147a2018-09-14 13:27:18 -0700395 Error setLayerColorTransform(Display display, Layer layer, const float* matrix) override;
Kevin DuBois9c0a1762018-10-16 13:32:31 -0700396 Error getDisplayedContentSamplingAttributes(Display display, PixelFormat* outFormat,
397 Dataspace* outDataspace,
398 uint8_t* outComponentMask) override;
Peiyong Lined531a32018-10-26 18:27:56 -0700399 Error getDisplayCapabilities(Display display,
400 std::vector<DisplayCapability>* outCapabilities) override;
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700401
Chia-I Wuaab99f52016-10-05 12:59:58 +0800402private:
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -0500403 class CommandWriter : public CommandWriterBase {
404 public:
405 CommandWriter(uint32_t initialMaxSize);
406 ~CommandWriter() override;
407
408 void setLayerInfo(uint32_t type, uint32_t appId);
Daniel Nicoara1f42e3a2017-04-10 13:27:32 -0400409 void setClientTargetMetadata(
410 const IVrComposerClient::BufferMetadata& metadata);
411 void setLayerBufferMetadata(
412 const IVrComposerClient::BufferMetadata& metadata);
413
414 private:
415 void writeBufferMetadata(
416 const IVrComposerClient::BufferMetadata& metadata);
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -0500417 };
418
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800419 // Many public functions above simply write a command into the command
420 // queue to batch the calls. validateDisplay and presentDisplay will call
421 // this function to execute the command queue.
422 Error execute();
423
Dominik Laskowski6231aaf2018-04-02 17:10:23 -0700424 sp<V2_1::IComposer> mComposer;
425
426 sp<V2_1::IComposerClient> mClient;
Dominik Laskowskie9ef7c42018-03-12 19:34:30 -0700427 sp<V2_2::IComposerClient> mClient_2_2;
428 sp<IComposerClient> mClient_2_3;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800429
430 // 64KiB minus a small space for metadata such as read/write pointers
431 static constexpr size_t kWriterInitialSize =
432 64 * 1024 / sizeof(uint32_t) - 16;
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -0500433 CommandWriter mWriter;
Chia-I Wucd8d7f02016-11-16 11:02:31 +0800434 CommandReader mReader;
Daniel Nicoara2f5f8a52016-12-20 16:11:58 -0500435
Hendrik Wagenaar87670ff2017-02-01 12:10:46 -0800436 // When true, the we attach to the vr_hwcomposer service instead of the
437 // hwcomposer. This allows us to redirect surfaces to 3d surfaces in vr.
438 const bool mIsUsingVrComposer;
Chia-I Wuaab99f52016-10-05 12:59:58 +0800439};
440
Lloyd Piquea822d522017-12-20 16:42:57 -0800441} // namespace impl
442
Chia-I Wuaab99f52016-10-05 12:59:58 +0800443} // namespace Hwc2
444
445} // namespace android
446
447#endif // ANDROID_SF_COMPOSER_HAL_H