1 /*
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
17 #include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
18 #include <android/native_window.h>
19 #include <android/surface_control.h>
20 #include <configstore/Utils.h>
21 #include <gui/HdrMetadata.h>
22 #include <gui/ISurfaceComposer.h>
23 #include <gui/Surface.h>
24 #include <gui/SurfaceComposerClient.h>
25 #include <gui/SurfaceControl.h>
26 #include <private/android/choreographer.h>
27 #include <surface_control_private.h>
28 #include <ui/DynamicDisplayInfo.h>
29 #include <utils/Timers.h>
30
31 using namespace android::hardware::configstore;
32 using namespace android::hardware::configstore::V1_0;
33 using namespace android;
34
35 using Transaction = SurfaceComposerClient::Transaction;
36
37 #define CHECK_NOT_NULL(name) \
38 LOG_ALWAYS_FATAL_IF(name == nullptr, "nullptr passed as " #name " argument");
39
40 #define CHECK_VALID_RECT(name) \
41 LOG_ALWAYS_FATAL_IF(!static_cast<const Rect&>(name).isValid(), \
42 "invalid arg passed as " #name " argument");
43
44 static_assert(static_cast<int>(ADATASPACE_UNKNOWN) == static_cast<int>(HAL_DATASPACE_UNKNOWN));
45 static_assert(static_cast<int>(ADATASPACE_SCRGB_LINEAR) ==
46 static_cast<int>(HAL_DATASPACE_V0_SCRGB_LINEAR));
47 static_assert(static_cast<int>(ADATASPACE_SRGB) == static_cast<int>(HAL_DATASPACE_V0_SRGB));
48 static_assert(static_cast<int>(ADATASPACE_SCRGB) == static_cast<int>(HAL_DATASPACE_V0_SCRGB));
49 static_assert(static_cast<int>(ADATASPACE_DISPLAY_P3) ==
50 static_cast<int>(HAL_DATASPACE_DISPLAY_P3));
51 static_assert(static_cast<int>(ADATASPACE_BT2020_PQ) == static_cast<int>(HAL_DATASPACE_BT2020_PQ));
52
ASurfaceTransaction_to_Transaction(ASurfaceTransaction * aSurfaceTransaction)53 Transaction* ASurfaceTransaction_to_Transaction(ASurfaceTransaction* aSurfaceTransaction) {
54 return reinterpret_cast<Transaction*>(aSurfaceTransaction);
55 }
56
ASurfaceControl_to_SurfaceControl(ASurfaceControl * aSurfaceControl)57 SurfaceControl* ASurfaceControl_to_SurfaceControl(ASurfaceControl* aSurfaceControl) {
58 return reinterpret_cast<SurfaceControl*>(aSurfaceControl);
59 }
60
SurfaceControl_acquire(SurfaceControl * surfaceControl)61 void SurfaceControl_acquire(SurfaceControl* surfaceControl) {
62 // incStrong/decStrong token must be the same, doesn't matter what it is
63 surfaceControl->incStrong((void*)SurfaceControl_acquire);
64 }
65
SurfaceControl_release(SurfaceControl * surfaceControl)66 void SurfaceControl_release(SurfaceControl* surfaceControl) {
67 // incStrong/decStrong token must be the same, doesn't matter what it is
68 surfaceControl->decStrong((void*)SurfaceControl_acquire);
69 }
70
ASurfaceControl_createFromWindow(ANativeWindow * window,const char * debug_name)71 ASurfaceControl* ASurfaceControl_createFromWindow(ANativeWindow* window, const char* debug_name) {
72 CHECK_NOT_NULL(window);
73 CHECK_NOT_NULL(debug_name);
74
75 sp<SurfaceComposerClient> client = new SurfaceComposerClient();
76 if (client->initCheck() != NO_ERROR) {
77 return nullptr;
78 }
79
80 Surface* surface = static_cast<Surface*>(window);
81 sp<IBinder> parentHandle = surface->getSurfaceControlHandle();
82
83 uint32_t flags = ISurfaceComposerClient::eFXSurfaceBufferState;
84 sp<SurfaceControl> surfaceControl;
85 if (parentHandle) {
86 surfaceControl =
87 client->createSurface(String8(debug_name), 0 /* width */, 0 /* height */,
88 // Format is only relevant for buffer queue layers.
89 PIXEL_FORMAT_UNKNOWN /* format */, flags, parentHandle);
90 } else {
91 surfaceControl =
92 client->createWithSurfaceParent(String8(debug_name), 0 /* width */, 0 /* height */,
93 // Format is only relevant for buffer queue layers.
94 PIXEL_FORMAT_UNKNOWN /* format */, flags,
95 static_cast<Surface*>(window));
96 }
97
98 if (!surfaceControl) {
99 return nullptr;
100 }
101
102 SurfaceControl_acquire(surfaceControl.get());
103 return reinterpret_cast<ASurfaceControl*>(surfaceControl.get());
104 }
105
ASurfaceControl_create(ASurfaceControl * parent,const char * debug_name)106 ASurfaceControl* ASurfaceControl_create(ASurfaceControl* parent, const char* debug_name) {
107 CHECK_NOT_NULL(parent);
108 CHECK_NOT_NULL(debug_name);
109
110 SurfaceComposerClient* client = ASurfaceControl_to_SurfaceControl(parent)->getClient().get();
111
112 SurfaceControl* surfaceControlParent = ASurfaceControl_to_SurfaceControl(parent);
113
114 uint32_t flags = ISurfaceComposerClient::eFXSurfaceBufferState;
115 sp<SurfaceControl> surfaceControl =
116 client->createSurface(String8(debug_name), 0 /* width */, 0 /* height */,
117 // Format is only relevant for buffer queue layers.
118 PIXEL_FORMAT_UNKNOWN /* format */, flags,
119 surfaceControlParent->getHandle());
120 if (!surfaceControl) {
121 return nullptr;
122 }
123
124 SurfaceControl_acquire(surfaceControl.get());
125 return reinterpret_cast<ASurfaceControl*>(surfaceControl.get());
126 }
127
ASurfaceControl_acquire(ASurfaceControl * aSurfaceControl)128 void ASurfaceControl_acquire(ASurfaceControl* aSurfaceControl) {
129 SurfaceControl* surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
130
131 SurfaceControl_acquire(surfaceControl);
132 }
133
ASurfaceControl_release(ASurfaceControl * aSurfaceControl)134 void ASurfaceControl_release(ASurfaceControl* aSurfaceControl) {
135 SurfaceControl* surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
136
137 SurfaceControl_release(surfaceControl);
138 }
139
140 struct ASurfaceControlStats {
141 std::variant<int64_t, sp<Fence>> acquireTimeOrFence;
142 sp<Fence> previousReleaseFence;
143 uint64_t frameNumber;
144 };
145
ASurfaceControl_registerSurfaceStatsListener(ASurfaceControl * control,int32_t id,void * context,ASurfaceControl_SurfaceStatsListener func)146 void ASurfaceControl_registerSurfaceStatsListener(ASurfaceControl* control, int32_t id,
147 void* context,
148 ASurfaceControl_SurfaceStatsListener func) {
149 SurfaceStatsCallback callback = [func, id](void* callback_context, nsecs_t, const sp<Fence>&,
150 const SurfaceStats& surfaceStats) {
151 ASurfaceControlStats aSurfaceControlStats;
152
153 aSurfaceControlStats.acquireTimeOrFence = surfaceStats.acquireTimeOrFence;
154 aSurfaceControlStats.previousReleaseFence = surfaceStats.previousReleaseFence;
155 aSurfaceControlStats.frameNumber = surfaceStats.eventStats.frameNumber;
156
157 (*func)(callback_context, id, &aSurfaceControlStats);
158 };
159
160 TransactionCompletedListener::getInstance()->addSurfaceStatsListener(context,
161 reinterpret_cast<void*>(func), ASurfaceControl_to_SurfaceControl(control), callback);
162 }
163
ASurfaceControl_unregisterSurfaceStatsListener(void * context,ASurfaceControl_SurfaceStatsListener func)164 void ASurfaceControl_unregisterSurfaceStatsListener(void* context,
165 ASurfaceControl_SurfaceStatsListener func) {
166 TransactionCompletedListener::getInstance()->removeSurfaceStatsListener(context,
167 reinterpret_cast<void*>(func));
168 }
169
ASurfaceControlStats_getAcquireTime(ASurfaceControlStats * stats)170 int64_t ASurfaceControlStats_getAcquireTime(ASurfaceControlStats* stats) {
171 if (const auto* fence = std::get_if<sp<Fence>>(&stats->acquireTimeOrFence)) {
172 // We got a fence instead of the acquire time due to latch unsignaled.
173 // Ideally the client could just get the acquire time dericly from
174 // the fence instead of calling this function which needs to block.
175 (*fence)->waitForever("ASurfaceControlStats_getAcquireTime");
176 return (*fence)->getSignalTime();
177 }
178
179 return std::get<int64_t>(stats->acquireTimeOrFence);
180 }
181
ASurfaceControlStats_getFrameNumber(ASurfaceControlStats * stats)182 uint64_t ASurfaceControlStats_getFrameNumber(ASurfaceControlStats* stats) {
183 return stats->frameNumber;
184 }
185
ASurfaceTransaction_create()186 ASurfaceTransaction* ASurfaceTransaction_create() {
187 Transaction* transaction = new Transaction;
188 return reinterpret_cast<ASurfaceTransaction*>(transaction);
189 }
190
ASurfaceTransaction_delete(ASurfaceTransaction * aSurfaceTransaction)191 void ASurfaceTransaction_delete(ASurfaceTransaction* aSurfaceTransaction) {
192 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
193 delete transaction;
194 }
195
ASurfaceTransaction_apply(ASurfaceTransaction * aSurfaceTransaction)196 void ASurfaceTransaction_apply(ASurfaceTransaction* aSurfaceTransaction) {
197 CHECK_NOT_NULL(aSurfaceTransaction);
198
199 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
200
201 transaction->apply();
202 }
203
204 struct ASurfaceTransactionStats {
205 std::unordered_map<ASurfaceControl*, ASurfaceControlStats> aSurfaceControlStats;
206 int64_t latchTime;
207 sp<Fence> presentFence;
208 bool transactionCompleted;
209 };
210
ASurfaceTransactionStats_getLatchTime(ASurfaceTransactionStats * aSurfaceTransactionStats)211 int64_t ASurfaceTransactionStats_getLatchTime(ASurfaceTransactionStats* aSurfaceTransactionStats) {
212 CHECK_NOT_NULL(aSurfaceTransactionStats);
213 return aSurfaceTransactionStats->latchTime;
214 }
215
ASurfaceTransactionStats_getPresentFenceFd(ASurfaceTransactionStats * aSurfaceTransactionStats)216 int ASurfaceTransactionStats_getPresentFenceFd(ASurfaceTransactionStats* aSurfaceTransactionStats) {
217 CHECK_NOT_NULL(aSurfaceTransactionStats);
218 LOG_ALWAYS_FATAL_IF(!aSurfaceTransactionStats->transactionCompleted,
219 "ASurfaceTransactionStats queried from an incomplete transaction callback");
220
221 auto& presentFence = aSurfaceTransactionStats->presentFence;
222 return (presentFence) ? presentFence->dup() : -1;
223 }
224
ASurfaceTransactionStats_getASurfaceControls(ASurfaceTransactionStats * aSurfaceTransactionStats,ASurfaceControl *** outASurfaceControls,size_t * outASurfaceControlsSize)225 void ASurfaceTransactionStats_getASurfaceControls(ASurfaceTransactionStats* aSurfaceTransactionStats,
226 ASurfaceControl*** outASurfaceControls,
227 size_t* outASurfaceControlsSize) {
228 CHECK_NOT_NULL(aSurfaceTransactionStats);
229 CHECK_NOT_NULL(outASurfaceControls);
230 CHECK_NOT_NULL(outASurfaceControlsSize);
231
232 size_t size = aSurfaceTransactionStats->aSurfaceControlStats.size();
233
234 SurfaceControl** surfaceControls = new SurfaceControl*[size];
235 ASurfaceControl** aSurfaceControls = reinterpret_cast<ASurfaceControl**>(surfaceControls);
236
237 size_t i = 0;
238 for (auto& [aSurfaceControl, aSurfaceControlStats] : aSurfaceTransactionStats->aSurfaceControlStats) {
239 aSurfaceControls[i] = aSurfaceControl;
240 i++;
241 }
242
243 *outASurfaceControls = aSurfaceControls;
244 *outASurfaceControlsSize = size;
245 }
246
ASurfaceTransactionStats_getAcquireTime(ASurfaceTransactionStats * aSurfaceTransactionStats,ASurfaceControl * aSurfaceControl)247 int64_t ASurfaceTransactionStats_getAcquireTime(ASurfaceTransactionStats* aSurfaceTransactionStats,
248 ASurfaceControl* aSurfaceControl) {
249 CHECK_NOT_NULL(aSurfaceTransactionStats);
250 CHECK_NOT_NULL(aSurfaceControl);
251
252 const auto& aSurfaceControlStats =
253 aSurfaceTransactionStats->aSurfaceControlStats.find(aSurfaceControl);
254 LOG_ALWAYS_FATAL_IF(
255 aSurfaceControlStats == aSurfaceTransactionStats->aSurfaceControlStats.end(),
256 "ASurfaceControl not found");
257
258 return ASurfaceControlStats_getAcquireTime(&aSurfaceControlStats->second);
259 }
260
ASurfaceTransactionStats_getPreviousReleaseFenceFd(ASurfaceTransactionStats * aSurfaceTransactionStats,ASurfaceControl * aSurfaceControl)261 int ASurfaceTransactionStats_getPreviousReleaseFenceFd(
262 ASurfaceTransactionStats* aSurfaceTransactionStats, ASurfaceControl* aSurfaceControl) {
263 CHECK_NOT_NULL(aSurfaceTransactionStats);
264 CHECK_NOT_NULL(aSurfaceControl);
265 LOG_ALWAYS_FATAL_IF(!aSurfaceTransactionStats->transactionCompleted,
266 "ASurfaceTransactionStats queried from an incomplete transaction callback");
267
268 const auto& aSurfaceControlStats =
269 aSurfaceTransactionStats->aSurfaceControlStats.find(aSurfaceControl);
270 LOG_ALWAYS_FATAL_IF(
271 aSurfaceControlStats == aSurfaceTransactionStats->aSurfaceControlStats.end(),
272 "ASurfaceControl not found");
273
274 auto& previousReleaseFence = aSurfaceControlStats->second.previousReleaseFence;
275 return (previousReleaseFence) ? previousReleaseFence->dup() : -1;
276 }
277
ASurfaceTransactionStats_releaseASurfaceControls(ASurfaceControl ** aSurfaceControls)278 void ASurfaceTransactionStats_releaseASurfaceControls(ASurfaceControl** aSurfaceControls) {
279 CHECK_NOT_NULL(aSurfaceControls);
280
281 SurfaceControl** surfaceControls = reinterpret_cast<SurfaceControl**>(aSurfaceControls);
282 delete[] surfaceControls;
283 }
284
ASurfaceTransaction_setOnComplete(ASurfaceTransaction * aSurfaceTransaction,void * context,ASurfaceTransaction_OnComplete func)285 void ASurfaceTransaction_setOnComplete(ASurfaceTransaction* aSurfaceTransaction, void* context,
286 ASurfaceTransaction_OnComplete func) {
287 CHECK_NOT_NULL(aSurfaceTransaction);
288 CHECK_NOT_NULL(func);
289
290 TransactionCompletedCallbackTakesContext callback = [func](void* callback_context,
291 nsecs_t latchTime,
292 const sp<Fence>& presentFence,
293 const std::vector<SurfaceControlStats>& surfaceControlStats) {
294 ASurfaceTransactionStats aSurfaceTransactionStats;
295
296 aSurfaceTransactionStats.latchTime = latchTime;
297 aSurfaceTransactionStats.presentFence = presentFence;
298 aSurfaceTransactionStats.transactionCompleted = true;
299
300 auto& aSurfaceControlStats = aSurfaceTransactionStats.aSurfaceControlStats;
301
302 for (const auto& [surfaceControl, latchTime, acquireTimeOrFence, presentFence,
303 previousReleaseFence, transformHint, frameEvents, ignore] : surfaceControlStats) {
304 ASurfaceControl* aSurfaceControl = reinterpret_cast<ASurfaceControl*>(surfaceControl.get());
305 aSurfaceControlStats[aSurfaceControl].acquireTimeOrFence = acquireTimeOrFence;
306 aSurfaceControlStats[aSurfaceControl].previousReleaseFence = previousReleaseFence;
307 }
308
309 (*func)(callback_context, &aSurfaceTransactionStats);
310 };
311
312 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
313
314 transaction->addTransactionCompletedCallback(callback, context);
315 }
316
ASurfaceTransaction_reparent(ASurfaceTransaction * aSurfaceTransaction,ASurfaceControl * aSurfaceControl,ASurfaceControl * newParentASurfaceControl)317 void ASurfaceTransaction_reparent(ASurfaceTransaction* aSurfaceTransaction,
318 ASurfaceControl* aSurfaceControl,
319 ASurfaceControl* newParentASurfaceControl) {
320 CHECK_NOT_NULL(aSurfaceTransaction);
321 CHECK_NOT_NULL(aSurfaceControl);
322
323 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
324 sp<SurfaceControl> newParentSurfaceControl = ASurfaceControl_to_SurfaceControl(
325 newParentASurfaceControl);
326 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
327
328 transaction->reparent(surfaceControl, newParentSurfaceControl);
329 }
330
ASurfaceTransaction_setVisibility(ASurfaceTransaction * aSurfaceTransaction,ASurfaceControl * aSurfaceControl,int8_t visibility)331 void ASurfaceTransaction_setVisibility(ASurfaceTransaction* aSurfaceTransaction,
332 ASurfaceControl* aSurfaceControl,
333 int8_t visibility) {
334 CHECK_NOT_NULL(aSurfaceTransaction);
335 CHECK_NOT_NULL(aSurfaceControl);
336
337 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
338 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
339
340 switch (visibility) {
341 case ASURFACE_TRANSACTION_VISIBILITY_SHOW:
342 transaction->show(surfaceControl);
343 break;
344 case ASURFACE_TRANSACTION_VISIBILITY_HIDE:
345 transaction->hide(surfaceControl);
346 break;
347 default:
348 LOG_ALWAYS_FATAL("invalid visibility %d", visibility);
349 }
350 }
351
ASurfaceTransaction_setZOrder(ASurfaceTransaction * aSurfaceTransaction,ASurfaceControl * aSurfaceControl,int32_t z_order)352 void ASurfaceTransaction_setZOrder(ASurfaceTransaction* aSurfaceTransaction,
353 ASurfaceControl* aSurfaceControl,
354 int32_t z_order) {
355 CHECK_NOT_NULL(aSurfaceTransaction);
356 CHECK_NOT_NULL(aSurfaceControl);
357
358 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
359 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
360
361 transaction->setLayer(surfaceControl, z_order);
362 }
363
ASurfaceTransaction_setBuffer(ASurfaceTransaction * aSurfaceTransaction,ASurfaceControl * aSurfaceControl,AHardwareBuffer * buffer,int acquire_fence_fd)364 void ASurfaceTransaction_setBuffer(ASurfaceTransaction* aSurfaceTransaction,
365 ASurfaceControl* aSurfaceControl,
366 AHardwareBuffer* buffer, int acquire_fence_fd) {
367 CHECK_NOT_NULL(aSurfaceTransaction);
368 CHECK_NOT_NULL(aSurfaceControl);
369
370 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
371 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
372
373 sp<GraphicBuffer> graphic_buffer(GraphicBuffer::fromAHardwareBuffer(buffer));
374
375 std::optional<sp<Fence>> fence = std::nullopt;
376 if (acquire_fence_fd != -1) {
377 fence = new Fence(acquire_fence_fd);
378 }
379 transaction->setBuffer(surfaceControl, graphic_buffer, fence);
380 }
381
ASurfaceTransaction_setGeometry(ASurfaceTransaction * aSurfaceTransaction,ASurfaceControl * aSurfaceControl,const ARect & source,const ARect & destination,int32_t transform)382 void ASurfaceTransaction_setGeometry(ASurfaceTransaction* aSurfaceTransaction,
383 ASurfaceControl* aSurfaceControl, const ARect& source,
384 const ARect& destination, int32_t transform) {
385 CHECK_NOT_NULL(aSurfaceTransaction);
386 CHECK_NOT_NULL(aSurfaceControl);
387 CHECK_VALID_RECT(source);
388 CHECK_VALID_RECT(destination);
389
390 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
391 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
392
393 Rect sourceRect = static_cast<const Rect&>(source);
394 Rect destRect = static_cast<const Rect&>(destination);
395 // Adjust the source so its top and left are not negative
396 sourceRect.left = std::max(sourceRect.left, 0);
397 sourceRect.top = std::max(sourceRect.top, 0);
398
399 if (!sourceRect.isValid()) {
400 sourceRect.makeInvalid();
401 }
402 transaction->setBufferCrop(surfaceControl, sourceRect);
403 transaction->setDestinationFrame(surfaceControl, destRect);
404 transaction->setTransform(surfaceControl, transform);
405 bool transformToInverseDisplay = (NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY & transform) ==
406 NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY;
407 transaction->setTransformToDisplayInverse(surfaceControl, transformToInverseDisplay);
408 }
409
ASurfaceTransaction_setCrop(ASurfaceTransaction * aSurfaceTransaction,ASurfaceControl * aSurfaceControl,const ARect & crop)410 void ASurfaceTransaction_setCrop(ASurfaceTransaction* aSurfaceTransaction,
411 ASurfaceControl* aSurfaceControl, const ARect& crop) {
412 CHECK_NOT_NULL(aSurfaceTransaction);
413 CHECK_NOT_NULL(aSurfaceControl);
414 CHECK_VALID_RECT(crop);
415
416 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
417 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
418
419 transaction->setCrop(surfaceControl, static_cast<const Rect&>(crop));
420 }
421
ASurfaceTransaction_setPosition(ASurfaceTransaction * aSurfaceTransaction,ASurfaceControl * aSurfaceControl,int32_t x,int32_t y)422 void ASurfaceTransaction_setPosition(ASurfaceTransaction* aSurfaceTransaction,
423 ASurfaceControl* aSurfaceControl, int32_t x, int32_t y) {
424 CHECK_NOT_NULL(aSurfaceTransaction);
425 CHECK_NOT_NULL(aSurfaceControl);
426
427 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
428 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
429
430 transaction->setPosition(surfaceControl, x, y);
431 }
432
ASurfaceTransaction_setBufferTransform(ASurfaceTransaction * aSurfaceTransaction,ASurfaceControl * aSurfaceControl,int32_t transform)433 void ASurfaceTransaction_setBufferTransform(ASurfaceTransaction* aSurfaceTransaction,
434 ASurfaceControl* aSurfaceControl, int32_t transform) {
435 CHECK_NOT_NULL(aSurfaceTransaction);
436 CHECK_NOT_NULL(aSurfaceControl);
437
438 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
439 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
440
441 transaction->setTransform(surfaceControl, transform);
442 bool transformToInverseDisplay = (NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY & transform) ==
443 NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY;
444 transaction->setTransformToDisplayInverse(surfaceControl, transformToInverseDisplay);
445 }
446
ASurfaceTransaction_setScale(ASurfaceTransaction * aSurfaceTransaction,ASurfaceControl * aSurfaceControl,float xScale,float yScale)447 void ASurfaceTransaction_setScale(ASurfaceTransaction* aSurfaceTransaction,
448 ASurfaceControl* aSurfaceControl, float xScale, float yScale) {
449 CHECK_NOT_NULL(aSurfaceTransaction);
450 CHECK_NOT_NULL(aSurfaceControl);
451 LOG_ALWAYS_FATAL_IF(xScale < 0, "negative value passed in for xScale");
452 LOG_ALWAYS_FATAL_IF(yScale < 0, "negative value passed in for yScale");
453
454 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
455 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
456
457 transaction->setMatrix(surfaceControl, xScale, 0, 0, yScale);
458 }
459
ASurfaceTransaction_setBufferTransparency(ASurfaceTransaction * aSurfaceTransaction,ASurfaceControl * aSurfaceControl,int8_t transparency)460 void ASurfaceTransaction_setBufferTransparency(ASurfaceTransaction* aSurfaceTransaction,
461 ASurfaceControl* aSurfaceControl,
462 int8_t transparency) {
463 CHECK_NOT_NULL(aSurfaceTransaction);
464 CHECK_NOT_NULL(aSurfaceControl);
465
466 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
467 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
468
469 uint32_t flags = (transparency == ASURFACE_TRANSACTION_TRANSPARENCY_OPAQUE) ?
470 layer_state_t::eLayerOpaque : 0;
471 transaction->setFlags(surfaceControl, flags, layer_state_t::eLayerOpaque);
472 }
473
ASurfaceTransaction_setDamageRegion(ASurfaceTransaction * aSurfaceTransaction,ASurfaceControl * aSurfaceControl,const ARect rects[],uint32_t count)474 void ASurfaceTransaction_setDamageRegion(ASurfaceTransaction* aSurfaceTransaction,
475 ASurfaceControl* aSurfaceControl,
476 const ARect rects[], uint32_t count) {
477 CHECK_NOT_NULL(aSurfaceTransaction);
478 CHECK_NOT_NULL(aSurfaceControl);
479
480 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
481 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
482
483 Region region;
484 for (uint32_t i = 0; i < count; ++i) {
485 region.orSelf(static_cast<const Rect&>(rects[i]));
486 }
487
488 // Hardware composer interprets a DamageRegion with a single Rect of {0,0,0,0} to be an
489 // undamaged region and {0,0,-1,-1} to be a fully damaged buffer. This is a confusing
490 // distinction for a public api. Instead, default both cases to be a fully damaged buffer.
491 if (count == 1 && region.getBounds().isEmpty()) {
492 transaction->setSurfaceDamageRegion(surfaceControl, Region::INVALID_REGION);
493 return;
494 }
495
496 transaction->setSurfaceDamageRegion(surfaceControl, region);
497 }
498
ASurfaceTransaction_setDesiredPresentTime(ASurfaceTransaction * aSurfaceTransaction,int64_t desiredPresentTime)499 void ASurfaceTransaction_setDesiredPresentTime(ASurfaceTransaction* aSurfaceTransaction,
500 int64_t desiredPresentTime) {
501 CHECK_NOT_NULL(aSurfaceTransaction);
502
503 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
504
505 transaction->setDesiredPresentTime(static_cast<nsecs_t>(desiredPresentTime));
506 }
507
ASurfaceTransaction_setBufferAlpha(ASurfaceTransaction * aSurfaceTransaction,ASurfaceControl * aSurfaceControl,float alpha)508 void ASurfaceTransaction_setBufferAlpha(ASurfaceTransaction* aSurfaceTransaction,
509 ASurfaceControl* aSurfaceControl,
510 float alpha) {
511 CHECK_NOT_NULL(aSurfaceTransaction);
512 CHECK_NOT_NULL(aSurfaceControl);
513
514 LOG_ALWAYS_FATAL_IF(alpha < 0.0 || alpha > 1.0, "invalid alpha");
515
516 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
517 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
518
519 transaction->setAlpha(surfaceControl, alpha);
520 }
521
ASurfaceTransaction_setBufferDataSpace(ASurfaceTransaction * aSurfaceTransaction,ASurfaceControl * aSurfaceControl,ADataSpace aDataSpace)522 void ASurfaceTransaction_setBufferDataSpace(ASurfaceTransaction* aSurfaceTransaction,
523 ASurfaceControl* aSurfaceControl,
524 ADataSpace aDataSpace) {
525 CHECK_NOT_NULL(aSurfaceTransaction);
526 CHECK_NOT_NULL(aSurfaceControl);
527
528 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
529 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
530 transaction->setDataspace(surfaceControl, static_cast<ui::Dataspace>(aDataSpace));
531 }
532
ASurfaceTransaction_setHdrMetadata_smpte2086(ASurfaceTransaction * aSurfaceTransaction,ASurfaceControl * aSurfaceControl,struct AHdrMetadata_smpte2086 * metadata)533 void ASurfaceTransaction_setHdrMetadata_smpte2086(ASurfaceTransaction* aSurfaceTransaction,
534 ASurfaceControl* aSurfaceControl,
535 struct AHdrMetadata_smpte2086* metadata) {
536 CHECK_NOT_NULL(aSurfaceTransaction);
537 CHECK_NOT_NULL(aSurfaceControl);
538
539 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
540 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
541
542 HdrMetadata hdrMetadata;
543
544 if (metadata) {
545 hdrMetadata.smpte2086.displayPrimaryRed.x = metadata->displayPrimaryRed.x;
546 hdrMetadata.smpte2086.displayPrimaryRed.y = metadata->displayPrimaryRed.y;
547 hdrMetadata.smpte2086.displayPrimaryGreen.x = metadata->displayPrimaryGreen.x;
548 hdrMetadata.smpte2086.displayPrimaryGreen.y = metadata->displayPrimaryGreen.y;
549 hdrMetadata.smpte2086.displayPrimaryBlue.x = metadata->displayPrimaryBlue.x;
550 hdrMetadata.smpte2086.displayPrimaryBlue.y = metadata->displayPrimaryBlue.y;
551 hdrMetadata.smpte2086.whitePoint.x = metadata->whitePoint.x;
552 hdrMetadata.smpte2086.whitePoint.y = metadata->whitePoint.y;
553 hdrMetadata.smpte2086.minLuminance = metadata->minLuminance;
554 hdrMetadata.smpte2086.maxLuminance = metadata->maxLuminance;
555
556 hdrMetadata.validTypes |= HdrMetadata::SMPTE2086;
557 } else {
558 hdrMetadata.validTypes &= ~HdrMetadata::SMPTE2086;
559 }
560
561 transaction->setHdrMetadata(surfaceControl, hdrMetadata);
562 }
563
ASurfaceTransaction_setHdrMetadata_cta861_3(ASurfaceTransaction * aSurfaceTransaction,ASurfaceControl * aSurfaceControl,struct AHdrMetadata_cta861_3 * metadata)564 void ASurfaceTransaction_setHdrMetadata_cta861_3(ASurfaceTransaction* aSurfaceTransaction,
565 ASurfaceControl* aSurfaceControl,
566 struct AHdrMetadata_cta861_3* metadata) {
567 CHECK_NOT_NULL(aSurfaceTransaction);
568 CHECK_NOT_NULL(aSurfaceControl);
569
570 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
571 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
572
573 HdrMetadata hdrMetadata;
574
575 if (metadata) {
576 hdrMetadata.cta8613.maxContentLightLevel = metadata->maxContentLightLevel;
577 hdrMetadata.cta8613.maxFrameAverageLightLevel = metadata->maxFrameAverageLightLevel;
578
579 hdrMetadata.validTypes |= HdrMetadata::CTA861_3;
580 } else {
581 hdrMetadata.validTypes &= ~HdrMetadata::CTA861_3;
582 }
583
584 transaction->setHdrMetadata(surfaceControl, hdrMetadata);
585 }
586
ASurfaceTransaction_setColor(ASurfaceTransaction * aSurfaceTransaction,ASurfaceControl * aSurfaceControl,float r,float g,float b,float alpha,ADataSpace dataspace)587 void ASurfaceTransaction_setColor(ASurfaceTransaction* aSurfaceTransaction,
588 ASurfaceControl* aSurfaceControl,
589 float r, float g, float b, float alpha,
590 ADataSpace dataspace) {
591 CHECK_NOT_NULL(aSurfaceTransaction);
592 CHECK_NOT_NULL(aSurfaceControl);
593
594 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
595 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
596
597 half3 color;
598 color.r = r;
599 color.g = g;
600 color.b = b;
601
602 transaction->setBackgroundColor(surfaceControl, color, alpha,
603 static_cast<ui::Dataspace>(dataspace));
604 }
605
ASurfaceTransaction_setFrameRate(ASurfaceTransaction * aSurfaceTransaction,ASurfaceControl * aSurfaceControl,float frameRate,int8_t compatibility)606 void ASurfaceTransaction_setFrameRate(ASurfaceTransaction* aSurfaceTransaction,
607 ASurfaceControl* aSurfaceControl, float frameRate,
608 int8_t compatibility) {
609 ASurfaceTransaction_setFrameRateWithChangeStrategy(
610 aSurfaceTransaction, aSurfaceControl, frameRate, compatibility,
611 ANATIVEWINDOW_CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS);
612 }
613
ASurfaceTransaction_setFrameRateWithChangeStrategy(ASurfaceTransaction * aSurfaceTransaction,ASurfaceControl * aSurfaceControl,float frameRate,int8_t compatibility,int8_t changeFrameRateStrategy)614 void ASurfaceTransaction_setFrameRateWithChangeStrategy(ASurfaceTransaction* aSurfaceTransaction,
615 ASurfaceControl* aSurfaceControl,
616 float frameRate, int8_t compatibility,
617 int8_t changeFrameRateStrategy) {
618 CHECK_NOT_NULL(aSurfaceTransaction);
619 CHECK_NOT_NULL(aSurfaceControl);
620 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
621 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
622 transaction->setFrameRate(surfaceControl, frameRate, compatibility, changeFrameRateStrategy);
623 }
624
ASurfaceTransaction_setEnableBackPressure(ASurfaceTransaction * aSurfaceTransaction,ASurfaceControl * aSurfaceControl,bool enableBackpressure)625 void ASurfaceTransaction_setEnableBackPressure(ASurfaceTransaction* aSurfaceTransaction,
626 ASurfaceControl* aSurfaceControl,
627 bool enableBackpressure) {
628 CHECK_NOT_NULL(aSurfaceControl);
629 CHECK_NOT_NULL(aSurfaceTransaction);
630
631 sp<SurfaceControl> surfaceControl = ASurfaceControl_to_SurfaceControl(aSurfaceControl);
632 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
633
634 const uint32_t flags = enableBackpressure ?
635 layer_state_t::eEnableBackpressure : 0;
636 transaction->setFlags(surfaceControl, flags, layer_state_t::eEnableBackpressure);
637 }
638
ASurfaceTransaction_setOnCommit(ASurfaceTransaction * aSurfaceTransaction,void * context,ASurfaceTransaction_OnCommit func)639 void ASurfaceTransaction_setOnCommit(ASurfaceTransaction* aSurfaceTransaction, void* context,
640 ASurfaceTransaction_OnCommit func) {
641 CHECK_NOT_NULL(aSurfaceTransaction);
642 CHECK_NOT_NULL(func);
643
644 TransactionCompletedCallbackTakesContext callback =
645 [func](void* callback_context, nsecs_t latchTime, const sp<Fence>& /* presentFence */,
646 const std::vector<SurfaceControlStats>& surfaceControlStats) {
647 ASurfaceTransactionStats aSurfaceTransactionStats;
648 aSurfaceTransactionStats.latchTime = latchTime;
649 aSurfaceTransactionStats.transactionCompleted = false;
650
651 auto& aSurfaceControlStats = aSurfaceTransactionStats.aSurfaceControlStats;
652 for (const auto& [surfaceControl, latchTime, acquireTimeOrFence, presentFence,
653 previousReleaseFence, transformHint, frameEvents, ignore] :
654 surfaceControlStats) {
655 ASurfaceControl* aSurfaceControl =
656 reinterpret_cast<ASurfaceControl*>(surfaceControl.get());
657 aSurfaceControlStats[aSurfaceControl].acquireTimeOrFence = acquireTimeOrFence;
658 }
659
660 (*func)(callback_context, &aSurfaceTransactionStats);
661 };
662
663 Transaction* transaction = ASurfaceTransaction_to_Transaction(aSurfaceTransaction);
664
665 transaction->addTransactionCommittedCallback(callback, context);
666 }
667
ASurfaceTransaction_setFrameTimeline(ASurfaceTransaction * aSurfaceTransaction,AVsyncId vsyncId)668 void ASurfaceTransaction_setFrameTimeline(ASurfaceTransaction* aSurfaceTransaction,
669 AVsyncId vsyncId) {
670 CHECK_NOT_NULL(aSurfaceTransaction);
671 const auto startTime = AChoreographer_getStartTimeNanosForVsyncId(vsyncId);
672 ASurfaceTransaction_to_Transaction(aSurfaceTransaction)
673 ->setFrameTimelineInfo({.vsyncId = vsyncId, .startTimeNanos = startTime});
674 }
675