blob: 0a466f424ceceb39c35c38e1830a8506c8c4789e [file] [log] [blame]
Marissa Wallf6a73fa2018-12-10 10:41:08 -08001/*
2 * Copyright 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
Marissa Wall1be5a102019-01-18 16:14:04 -080017#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
Marissa Wallf6a73fa2018-12-10 10:41:08 -080018#include <android/native_window.h>
19#include <android/surface_control.h>
20
Marissa Wall1be5a102019-01-18 16:14:04 -080021#include <configstore/Utils.h>
22
23#include <gui/HdrMetadata.h>
24#include <gui/ISurfaceComposer.h>
Marissa Wallf6a73fa2018-12-10 10:41:08 -080025#include <gui/Surface.h>
26#include <gui/SurfaceComposerClient.h>
27#include <gui/SurfaceControl.h>
28
Marissa Wall1be5a102019-01-18 16:14:04 -080029#include <ui/HdrCapabilities.h>
30
31#include <utils/Timers.h>
32
33using namespace android::hardware::configstore;
34using namespace android::hardware::configstore::V1_0;
Marissa Wallf6a73fa2018-12-10 10:41:08 -080035using namespace android;
Marissa Wall1be5a102019-01-18 16:14:04 -080036using android::hardware::configstore::V1_0::ISurfaceFlingerConfigs;
Marissa Wallf6a73fa2018-12-10 10:41:08 -080037
38using Transaction = SurfaceComposerClient::Transaction;
39
40#define CHECK_NOT_NULL(name) \
41 LOG_ALWAYS_FATAL_IF(name == nullptr, "nullptr passed as " #name " argument");
42
43#define CHECK_VALID_RECT(name) \
44 LOG_ALWAYS_FATAL_IF(!static_cast<const Rect&>(name).isValid(), \
45 "invalid arg passed as " #name " argument");
46
Valerie Hau5bbfd512019-01-22 17:39:43 -080047static bool getWideColorSupport(const sp<SurfaceControl>& surfaceControl) {
48 sp<SurfaceComposerClient> client = surfaceControl->getClient();
Dominik Laskowski3316a0a2019-01-25 02:56:41 -080049
50 const sp<IBinder> display = client->getInternalDisplayToken();
51 if (display == nullptr) {
52 ALOGE("unable to get wide color support for disconnected internal display");
53 return false;
54 }
55
Peiyong Lin0d04f322019-01-24 17:49:46 -080056 bool isWideColorDisplay = false;
57 status_t err = client->isWideColorDisplay(display, &isWideColorDisplay);
Valerie Hau5bbfd512019-01-22 17:39:43 -080058 if (err) {
59 ALOGE("unable to get wide color support");
60 return false;
61 }
Peiyong Lin0d04f322019-01-24 17:49:46 -080062 return isWideColorDisplay;
Valerie Hau5bbfd512019-01-22 17:39:43 -080063}
64
65static bool getHdrSupport(const sp<SurfaceControl>& surfaceControl) {
66 sp<SurfaceComposerClient> client = surfaceControl->getClient();
Dominik Laskowski3316a0a2019-01-25 02:56:41 -080067
68 const sp<IBinder> display = client->getInternalDisplayToken();
69 if (display == nullptr) {
70 ALOGE("unable to get hdr capabilities for disconnected internal display");
71 return false;
72 }
Valerie Hau5bbfd512019-01-22 17:39:43 -080073
74 HdrCapabilities hdrCapabilities;
75 status_t err = client->getHdrCapabilities(display, &hdrCapabilities);
76 if (err) {
77 ALOGE("unable to get hdr capabilities");
78 return false;
79 }
80
81 return !hdrCapabilities.getSupportedHdrTypes().empty();
82}
83
84static bool isDataSpaceValid(const sp<SurfaceControl>& surfaceControl, ADataSpace dataSpace) {
85 static_assert(static_cast<int>(ADATASPACE_UNKNOWN) == static_cast<int>(HAL_DATASPACE_UNKNOWN));
86 static_assert(static_cast<int>(ADATASPACE_SCRGB_LINEAR) == static_cast<int>(HAL_DATASPACE_V0_SCRGB_LINEAR));
87 static_assert(static_cast<int>(ADATASPACE_SRGB) == static_cast<int>(HAL_DATASPACE_V0_SRGB));
88 static_assert(static_cast<int>(ADATASPACE_SCRGB) == static_cast<int>(HAL_DATASPACE_V0_SCRGB));
89 static_assert(static_cast<int>(ADATASPACE_DISPLAY_P3) == static_cast<int>(HAL_DATASPACE_DISPLAY_P3));
90 static_assert(static_cast<int>(ADATASPACE_BT2020_PQ) == static_cast<int>(HAL_DATASPACE_BT2020_PQ));
91
92 switch (static_cast<android_dataspace_t>(dataSpace)) {
93 case HAL_DATASPACE_UNKNOWN:
94 case HAL_DATASPACE_V0_SRGB:
95 return true;
96 // These data space need wide gamut support.
97 case HAL_DATASPACE_V0_SCRGB_LINEAR:
98 case HAL_DATASPACE_V0_SCRGB:
99 case HAL_DATASPACE_DISPLAY_P3:
100 return getWideColorSupport(surfaceControl);
101 // These data space need HDR support.
102 case HAL_DATASPACE_BT2020_PQ:
Valerie Hau5e18c432019-08-26 12:48:49 -0700103 if (!getHdrSupport(surfaceControl)) {
104 ALOGE("Invalid dataspace - device does not support hdr");
105 return false;
106 }
107 return true;
Valerie Hau5bbfd512019-01-22 17:39:43 -0800108 default:
109 return false;
110 }
111}
112
Marissa Wallf6a73fa2018-12-10 10:41:08 -0800113Transaction* ASurfaceTransaction_to_Transaction(ASurfaceTransaction* aSurfaceTransaction) {
114 return reinterpret_cast<Transaction*>(aSurfaceTransaction);
115}
116
117SurfaceControl* ASurfaceControl_to_SurfaceControl(ASurfaceControl* aSurfaceControl) {
118 return reinterpret_cast<SurfaceControl*>(aSurfaceControl);
119}
120
121void SurfaceControl_acquire(SurfaceControl* surfaceControl) {
122 // incStrong/decStrong token must be the same, doesn't matter what it is
123 surfaceControl->incStrong((void*)SurfaceControl_acquire);
124}
125
126void SurfaceControl_release(SurfaceControl* surfaceControl) {
127 // incStrong/decStrong token must be the same, doesn't matter what it is
128 surfaceControl->decStrong((void*)SurfaceControl_acquire);
129}
130
131ASurfaceControl* ASurfaceControl_createFromWindow(ANativeWindow* window, const char* debug_name) {
132 CHECK_NOT_NULL(window);
133 CHECK_NOT_NULL(debug_name);
134
135 sp<SurfaceComposerClient> client = new SurfaceComposerClient();
136 if (client->initCheck() != NO_ERROR) {
137 return nullptr;
138 }
139
140 uint32_t flags = ISurfaceComposerClient::eFXSurfaceBufferState;
141 sp<SurfaceControl> surfaceControl =
142 client->createWithSurfaceParent(String8(debug_name), 0 /* width */, 0 /* height */,
143 // Format is only relevant for buffer queue layers.
144 PIXEL_FORMAT_UNKNOWN /* format */, flags,
145 static_cast<Surface*>(window));
146 if (!surfaceControl) {
147 return nullptr;
148 }
149
150 SurfaceControl_acquire(surfaceControl.get());
151 return reinterpret_cast<ASurfaceControl*>(surfaceControl.get());
152}
153
154ASurfaceControl* ASurfaceControl_create(ASurfaceControl* parent, const char* debug_name) {
155 CHECK_NOT_NULL(parent);
156 CHECK_NOT_NULL(debug_name);
157
158 SurfaceComposerClient* client = ASurfaceControl_to_SurfaceControl(parent)->getClient().get();
159
160 SurfaceControl* surfaceControlParent = ASurfaceControl_to_SurfaceControl(parent);
161
162 uint32_t flags = ISurfaceComposerClient::eFXSurfaceBufferState;
163 sp<SurfaceControl> surfaceControl =
164 client->createSurface(String8(debug_name), 0 /* width */, 0 /* height */,
165 // Format is only relevant for buffer queue layers.
166 PIXEL_FORMAT_UNKNOWN /* format */, flags,
167 surfaceControlParent);
168 if (!surfaceControl) {
169 return nullptr;
170 }
171
172 SurfaceControl_acquire(surfaceControl.get());
173 return reinterpret_cast<ASurfaceControl*>(surfaceControl.get());
174}
175
Marissa Wall1be5a102019-01-18 16:14:04 -0800176void ASurfaceControl_release(ASurfaceControl* aSurfaceControl) {
Marissa Wallf6a73fa2018-12-10 10:41:08 -0800177 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
178
Marissa Wallf6a73fa2018-12-10 10:41:08 -0800179 SurfaceControl_release(surfaceControl.get());
180}
181
182ASurfaceTransaction* ASurfaceTransaction_create() {
183 Transaction* transaction = new Transaction;
184 return reinterpret_cast<ASurfaceTransaction*>(transaction);
185}
186
187void ASurfaceTransaction_delete(ASurfaceTransaction* aSurfaceTransaction) {
188 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
189 delete transaction;
190}
191
192void ASurfaceTransaction_apply(ASurfaceTransaction* aSurfaceTransaction) {
193 CHECK_NOT_NULL(aSurfaceTransaction);
194
195 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
196
197 transaction->apply();
198}
199
Marissa Wall1be5a102019-01-18 16:14:04 -0800200typedef struct ASurfaceControlStats {
201 int64_t acquireTime;
202 sp<Fence> previousReleaseFence;
203} ASurfaceControlStats;
204
205struct ASurfaceTransactionStats {
206 std::unordered_map<ASurfaceControl*, ASurfaceControlStats> aSurfaceControlStats;
207 int64_t latchTime;
208 sp<Fence> presentFence;
209};
210
211int64_t ASurfaceTransactionStats_getLatchTime(ASurfaceTransactionStats* aSurfaceTransactionStats) {
212 CHECK_NOT_NULL(aSurfaceTransactionStats);
213 return aSurfaceTransactionStats->latchTime;
214}
215
216int ASurfaceTransactionStats_getPresentFenceFd(ASurfaceTransactionStats* aSurfaceTransactionStats) {
217 CHECK_NOT_NULL(aSurfaceTransactionStats);
218 auto& presentFence = aSurfaceTransactionStats->presentFence;
219 return (presentFence) ? presentFence->dup() : -1;
220}
221
222void ASurfaceTransactionStats_getASurfaceControls(ASurfaceTransactionStats* aSurfaceTransactionStats,
223 ASurfaceControl*** outASurfaceControls,
224 size_t* outASurfaceControlsSize) {
225 CHECK_NOT_NULL(aSurfaceTransactionStats);
226 CHECK_NOT_NULL(outASurfaceControls);
227 CHECK_NOT_NULL(outASurfaceControlsSize);
228
229 size_t size = aSurfaceTransactionStats->aSurfaceControlStats.size();
230
231 SurfaceControl** surfaceControls = new SurfaceControl*[size];
232 ASurfaceControl** aSurfaceControls = reinterpret_cast<ASurfaceControl**>(surfaceControls);
233
234 size_t i = 0;
235 for (auto& [aSurfaceControl, aSurfaceControlStats] : aSurfaceTransactionStats->aSurfaceControlStats) {
236 aSurfaceControls[i] = aSurfaceControl;
237 i++;
238 }
239
240 *outASurfaceControls = aSurfaceControls;
241 *outASurfaceControlsSize = size;
242}
243
244int64_t ASurfaceTransactionStats_getAcquireTime(ASurfaceTransactionStats* aSurfaceTransactionStats,
245 ASurfaceControl* aSurfaceControl) {
246 CHECK_NOT_NULL(aSurfaceTransactionStats);
247 CHECK_NOT_NULL(aSurfaceControl);
248
249 const auto& aSurfaceControlStats =
250 aSurfaceTransactionStats->aSurfaceControlStats.find(aSurfaceControl);
251 LOG_ALWAYS_FATAL_IF(
252 aSurfaceControlStats == aSurfaceTransactionStats->aSurfaceControlStats.end(),
253 "ASurfaceControl not found");
254
255 return aSurfaceControlStats->second.acquireTime;
256}
257
258int ASurfaceTransactionStats_getPreviousReleaseFenceFd(
259 ASurfaceTransactionStats* aSurfaceTransactionStats, ASurfaceControl* aSurfaceControl) {
260 CHECK_NOT_NULL(aSurfaceTransactionStats);
261 CHECK_NOT_NULL(aSurfaceControl);
262
263 const auto& aSurfaceControlStats =
264 aSurfaceTransactionStats->aSurfaceControlStats.find(aSurfaceControl);
265 LOG_ALWAYS_FATAL_IF(
266 aSurfaceControlStats == aSurfaceTransactionStats->aSurfaceControlStats.end(),
267 "ASurfaceControl not found");
268
269 auto& previousReleaseFence = aSurfaceControlStats->second.previousReleaseFence;
270 return (previousReleaseFence) ? previousReleaseFence->dup() : -1;
271}
272
273void ASurfaceTransactionStats_releaseASurfaceControls(ASurfaceControl** aSurfaceControls) {
274 CHECK_NOT_NULL(aSurfaceControls);
275
276 SurfaceControl** surfaceControls = reinterpret_cast<SurfaceControl**>(aSurfaceControls);
277 delete[] surfaceControls;
278}
279
Marissa Wallf6a73fa2018-12-10 10:41:08 -0800280void ASurfaceTransaction_setOnComplete(ASurfaceTransaction* aSurfaceTransaction, void* context,
281 ASurfaceTransaction_OnComplete func) {
282 CHECK_NOT_NULL(aSurfaceTransaction);
283 CHECK_NOT_NULL(context);
284 CHECK_NOT_NULL(func);
285
286 TransactionCompletedCallbackTakesContext callback = [func](void* callback_context,
Marissa Wall1be5a102019-01-18 16:14:04 -0800287 nsecs_t latchTime,
288 const sp<Fence>& presentFence,
289 const std::vector<SurfaceControlStats>& surfaceControlStats) {
290 ASurfaceTransactionStats aSurfaceTransactionStats;
291
292 aSurfaceTransactionStats.latchTime = latchTime;
293 aSurfaceTransactionStats.presentFence = presentFence;
294
295 auto& aSurfaceControlStats = aSurfaceTransactionStats.aSurfaceControlStats;
296
Valerie Haud6a222e2020-01-29 14:27:09 -0800297 for (const auto& [surfaceControl, latchTime, acquireTime, presentFence, previousReleaseFence, transformHint, frameEvents] : surfaceControlStats) {
Marissa Wall1be5a102019-01-18 16:14:04 -0800298 ASurfaceControl* aSurfaceControl = reinterpret_cast<ASurfaceControl*>(surfaceControl.get());
299 aSurfaceControlStats[aSurfaceControl].acquireTime = acquireTime;
300 aSurfaceControlStats[aSurfaceControl].previousReleaseFence = previousReleaseFence;
301 }
302
303 (*func)(callback_context, &aSurfaceTransactionStats);
Marissa Wallf6a73fa2018-12-10 10:41:08 -0800304 };
305
306 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
307
308 transaction->addTransactionCompletedCallback(callback, context);
309}
310
Marissa Wall1be5a102019-01-18 16:14:04 -0800311void ASurfaceTransaction_reparent(ASurfaceTransaction* aSurfaceTransaction,
312 ASurfaceControl* aSurfaceControl,
313 ASurfaceControl* newParentASurfaceControl) {
314 CHECK_NOT_NULL(aSurfaceTransaction);
315 CHECK_NOT_NULL(aSurfaceControl);
316
317 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
318 sp<SurfaceControl> newParentSurfaceControl = ASurfaceControl_to_SurfaceControl(
319 newParentASurfaceControl);
Marissa Wall1be5a102019-01-18 16:14:04 -0800320 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
321
Pablo Gamito117040c2020-09-14 08:24:41 +0000322 transaction->reparent(surfaceControl, newParentSurfaceControl);
Marissa Wall1be5a102019-01-18 16:14:04 -0800323}
324
325void ASurfaceTransaction_setVisibility(ASurfaceTransaction* aSurfaceTransaction,
326 ASurfaceControl* aSurfaceControl,
Marissa Wallf6a73fa2018-12-10 10:41:08 -0800327 int8_t visibility) {
328 CHECK_NOT_NULL(aSurfaceTransaction);
329 CHECK_NOT_NULL(aSurfaceControl);
330
331 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
332 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
333
334 switch (visibility) {
335 case ASURFACE_TRANSACTION_VISIBILITY_SHOW:
336 transaction->show(surfaceControl);
337 break;
338 case ASURFACE_TRANSACTION_VISIBILITY_HIDE:
339 transaction->hide(surfaceControl);
340 break;
341 default:
342 LOG_ALWAYS_FATAL("invalid visibility %d", visibility);
343 }
344}
345
Marissa Wall1be5a102019-01-18 16:14:04 -0800346void ASurfaceTransaction_setZOrder(ASurfaceTransaction* aSurfaceTransaction,
347 ASurfaceControl* aSurfaceControl,
Marissa Wallf6a73fa2018-12-10 10:41:08 -0800348 int32_t z_order) {
349 CHECK_NOT_NULL(aSurfaceTransaction);
350 CHECK_NOT_NULL(aSurfaceControl);
351
352 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
353 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
354
355 transaction->setLayer(surfaceControl, z_order);
356}
357
Marissa Wall1be5a102019-01-18 16:14:04 -0800358void ASurfaceTransaction_setBuffer(ASurfaceTransaction* aSurfaceTransaction,
359 ASurfaceControl* aSurfaceControl,
360 AHardwareBuffer* buffer, int acquire_fence_fd) {
Marissa Wallf6a73fa2018-12-10 10:41:08 -0800361 CHECK_NOT_NULL(aSurfaceTransaction);
362 CHECK_NOT_NULL(aSurfaceControl);
363
364 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
365 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
366
367 sp<GraphicBuffer> graphic_buffer(reinterpret_cast<GraphicBuffer*>(buffer));
368
369 transaction->setBuffer(surfaceControl, graphic_buffer);
Marissa Wall1be5a102019-01-18 16:14:04 -0800370 if (acquire_fence_fd != -1) {
371 sp<Fence> fence = new Fence(acquire_fence_fd);
Marissa Wallf6a73fa2018-12-10 10:41:08 -0800372 transaction->setAcquireFence(surfaceControl, fence);
373 }
374}
375
376void ASurfaceTransaction_setGeometry(ASurfaceTransaction* aSurfaceTransaction,
377 ASurfaceControl* aSurfaceControl, const ARect& source,
378 const ARect& destination, int32_t transform) {
379 CHECK_NOT_NULL(aSurfaceTransaction);
380 CHECK_NOT_NULL(aSurfaceControl);
381 CHECK_VALID_RECT(source);
382 CHECK_VALID_RECT(destination);
383
384 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
385 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
386
387 transaction->setCrop(surfaceControl, static_cast<const Rect&>(source));
388 transaction->setFrame(surfaceControl, static_cast<const Rect&>(destination));
389 transaction->setTransform(surfaceControl, transform);
Vishnu Nair1ad69542019-05-23 16:27:45 +0800390 bool transformToInverseDisplay = (NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY & transform) ==
391 NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY;
392 transaction->setTransformToDisplayInverse(surfaceControl, transformToInverseDisplay);
Marissa Wallf6a73fa2018-12-10 10:41:08 -0800393}
394
395void ASurfaceTransaction_setBufferTransparency(ASurfaceTransaction* aSurfaceTransaction,
396 ASurfaceControl* aSurfaceControl,
397 int8_t transparency) {
398 CHECK_NOT_NULL(aSurfaceTransaction);
399 CHECK_NOT_NULL(aSurfaceControl);
400
401 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
402 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
403
404 uint32_t flags = (transparency == ASURFACE_TRANSACTION_TRANSPARENCY_OPAQUE) ?
405 layer_state_t::eLayerOpaque : 0;
406 transaction->setFlags(surfaceControl, flags, layer_state_t::eLayerOpaque);
407}
408
Marissa Wall1be5a102019-01-18 16:14:04 -0800409void ASurfaceTransaction_setDamageRegion(ASurfaceTransaction* aSurfaceTransaction,
410 ASurfaceControl* aSurfaceControl,
Marissa Wallf6a73fa2018-12-10 10:41:08 -0800411 const ARect rects[], uint32_t count) {
412 CHECK_NOT_NULL(aSurfaceTransaction);
413 CHECK_NOT_NULL(aSurfaceControl);
414
415 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
416 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
417
418 Region region;
419 for (uint32_t i = 0; i < count; ++i) {
Marissa Wallbb9b14f2019-04-23 14:10:15 -0700420 region.orSelf(static_cast<const Rect&>(rects[i]));
421 }
422
423 // Hardware composer interprets a DamageRegion with a single Rect of {0,0,0,0} to be an
424 // undamaged region and {0,0,-1,-1} to be a fully damaged buffer. This is a confusing
425 // distinction for a public api. Instead, default both cases to be a fully damaged buffer.
426 if (count == 1 && region.getBounds().isEmpty()) {
427 transaction->setSurfaceDamageRegion(surfaceControl, Region::INVALID_REGION);
428 return;
Marissa Wallf6a73fa2018-12-10 10:41:08 -0800429 }
430
431 transaction->setSurfaceDamageRegion(surfaceControl, region);
432}
Marissa Wall1be5a102019-01-18 16:14:04 -0800433
434void ASurfaceTransaction_setDesiredPresentTime(ASurfaceTransaction* aSurfaceTransaction,
435 int64_t desiredPresentTime) {
436 CHECK_NOT_NULL(aSurfaceTransaction);
437
438 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
439
440 transaction->setDesiredPresentTime(static_cast<nsecs_t>(desiredPresentTime));
441}
442
443void ASurfaceTransaction_setBufferAlpha(ASurfaceTransaction* aSurfaceTransaction,
444 ASurfaceControl* aSurfaceControl,
445 float alpha) {
446 CHECK_NOT_NULL(aSurfaceTransaction);
447 CHECK_NOT_NULL(aSurfaceControl);
448
449 LOG_ALWAYS_FATAL_IF(alpha < 0.0 || alpha > 1.0, "invalid alpha");
450
451 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
452 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
453
454 transaction->setAlpha(surfaceControl, alpha);
455}
456
Marissa Wall7f24f792019-02-07 14:06:04 -0800457void ASurfaceTransaction_setBufferDataSpace(ASurfaceTransaction* aSurfaceTransaction,
458 ASurfaceControl* aSurfaceControl,
459 ADataSpace aDataSpace) {
460 CHECK_NOT_NULL(aSurfaceTransaction);
461 CHECK_NOT_NULL(aSurfaceControl);
462
463 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
Valerie Hau5e18c432019-08-26 12:48:49 -0700464 if (!isDataSpaceValid(surfaceControl, aDataSpace)) {
465 ALOGE("Failed to set buffer dataspace - invalid dataspace");
466 return;
467 }
Marissa Wall7f24f792019-02-07 14:06:04 -0800468 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
Marissa Wall7f24f792019-02-07 14:06:04 -0800469 transaction->setDataspace(surfaceControl, static_cast<ui::Dataspace>(aDataSpace));
470}
471
Marissa Wall1be5a102019-01-18 16:14:04 -0800472void ASurfaceTransaction_setHdrMetadata_smpte2086(ASurfaceTransaction* aSurfaceTransaction,
473 ASurfaceControl* aSurfaceControl,
474 struct AHdrMetadata_smpte2086* metadata) {
475 CHECK_NOT_NULL(aSurfaceTransaction);
476 CHECK_NOT_NULL(aSurfaceControl);
477
478 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
479 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
480
481 HdrMetadata hdrMetadata;
482
483 if (metadata) {
484 hdrMetadata.smpte2086.displayPrimaryRed.x = metadata->displayPrimaryRed.x;
485 hdrMetadata.smpte2086.displayPrimaryRed.y = metadata->displayPrimaryRed.y;
486 hdrMetadata.smpte2086.displayPrimaryGreen.x = metadata->displayPrimaryGreen.x;
487 hdrMetadata.smpte2086.displayPrimaryGreen.y = metadata->displayPrimaryGreen.y;
488 hdrMetadata.smpte2086.displayPrimaryBlue.x = metadata->displayPrimaryBlue.x;
489 hdrMetadata.smpte2086.displayPrimaryBlue.y = metadata->displayPrimaryBlue.y;
490 hdrMetadata.smpte2086.whitePoint.x = metadata->whitePoint.x;
491 hdrMetadata.smpte2086.whitePoint.y = metadata->whitePoint.y;
492 hdrMetadata.smpte2086.minLuminance = metadata->minLuminance;
493 hdrMetadata.smpte2086.maxLuminance = metadata->maxLuminance;
494
495 hdrMetadata.validTypes |= HdrMetadata::SMPTE2086;
496 } else {
497 hdrMetadata.validTypes &= ~HdrMetadata::SMPTE2086;
498 }
499
500 transaction->setHdrMetadata(surfaceControl, hdrMetadata);
501}
502
503void ASurfaceTransaction_setHdrMetadata_cta861_3(ASurfaceTransaction* aSurfaceTransaction,
504 ASurfaceControl* aSurfaceControl,
505 struct AHdrMetadata_cta861_3* metadata) {
506 CHECK_NOT_NULL(aSurfaceTransaction);
507 CHECK_NOT_NULL(aSurfaceControl);
508
509 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
510 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
511
512 HdrMetadata hdrMetadata;
513
514 if (metadata) {
515 hdrMetadata.cta8613.maxContentLightLevel = metadata->maxContentLightLevel;
516 hdrMetadata.cta8613.maxFrameAverageLightLevel = metadata->maxFrameAverageLightLevel;
517
518 hdrMetadata.validTypes |= HdrMetadata::CTA861_3;
519 } else {
520 hdrMetadata.validTypes &= ~HdrMetadata::CTA861_3;
521 }
522
523 transaction->setHdrMetadata(surfaceControl, hdrMetadata);
524}
Valerie Hau5bbfd512019-01-22 17:39:43 -0800525
526void ASurfaceTransaction_setColor(ASurfaceTransaction* aSurfaceTransaction,
527 ASurfaceControl* aSurfaceControl,
528 float r, float g, float b, float alpha,
529 ADataSpace dataspace) {
530 CHECK_NOT_NULL(aSurfaceTransaction);
531 CHECK_NOT_NULL(aSurfaceControl);
532
533 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
Valerie Hau5e18c432019-08-26 12:48:49 -0700534 if (!isDataSpaceValid(surfaceControl, dataspace)) {
535 ALOGE("Failed to set buffer dataspace - invalid dataspace");
536 return;
537 }
Valerie Hau5bbfd512019-01-22 17:39:43 -0800538 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
539
540 half3 color;
541 color.r = r;
542 color.g = g;
543 color.b = b;
544
Valerie Hau6bc482312019-01-29 15:01:53 -0800545 transaction->setBackgroundColor(surfaceControl, color, alpha, static_cast<ui::Dataspace>(dataspace));
Valerie Hau5bbfd512019-01-22 17:39:43 -0800546}
Steven Thomas6cf051e2020-01-14 11:37:21 -0800547
548void ASurfaceTransaction_setFrameRate(ASurfaceTransaction* aSurfaceTransaction,
Steven Thomasdd7bf2f2020-01-31 18:50:02 -0800549 ASurfaceControl* aSurfaceControl, float frameRate,
550 int8_t compatibility) {
Steven Thomas6cf051e2020-01-14 11:37:21 -0800551 CHECK_NOT_NULL(aSurfaceTransaction);
552 CHECK_NOT_NULL(aSurfaceControl);
Steven Thomas6cf051e2020-01-14 11:37:21 -0800553 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
Steven Thomasdd7bf2f2020-01-31 18:50:02 -0800554 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
555 transaction->setFrameRate(surfaceControl, frameRate, compatibility);
Steven Thomas6cf051e2020-01-14 11:37:21 -0800556}