1 /*
2 * Copyright (C) 2007 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 //#define LOG_NDEBUG 0
18 #undef LOG_TAG
19 #define LOG_TAG "Layer"
20 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
21
22 #include <stdlib.h>
23 #include <stdint.h>
24 #include <sys/types.h>
25 #include <math.h>
26
27 #include <cutils/compiler.h>
28 #include <cutils/native_handle.h>
29 #include <cutils/properties.h>
30
31 #include <utils/Errors.h>
32 #include <utils/Log.h>
33 #include <utils/NativeHandle.h>
34 #include <utils/StopWatch.h>
35 #include <utils/Trace.h>
36
37 #include <ui/GraphicBuffer.h>
38 #include <ui/PixelFormat.h>
39
40 #include <gui/BufferItem.h>
41 #include <gui/Surface.h>
42
43 #include "clz.h"
44 #include "Colorizer.h"
45 #include "DisplayDevice.h"
46 #include "Layer.h"
47 #include "MonitoredProducer.h"
48 #include "SurfaceFlinger.h"
49
50 #include "DisplayHardware/HWComposer.h"
51
52 #include "RenderEngine/RenderEngine.h"
53
54 #include <mutex>
55
56 #define DEBUG_RESIZE 0
57
58 namespace android {
59
60 // ---------------------------------------------------------------------------
61
62 int32_t Layer::sSequence = 1;
63
Layer(SurfaceFlinger * flinger,const sp<Client> & client,const String8 & name,uint32_t w,uint32_t h,uint32_t flags)64 Layer::Layer(SurfaceFlinger* flinger, const sp<Client>& client,
65 const String8& name, uint32_t w, uint32_t h, uint32_t flags)
66 : contentDirty(false),
67 sequence(uint32_t(android_atomic_inc(&sSequence))),
68 mFlinger(flinger),
69 mTextureName(-1U),
70 mPremultipliedAlpha(true),
71 mName("unnamed"),
72 mFormat(PIXEL_FORMAT_NONE),
73 mTransactionFlags(0),
74 mPendingStateMutex(),
75 mPendingStates(),
76 mQueuedFrames(0),
77 mSidebandStreamChanged(false),
78 mCurrentTransform(0),
79 mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE),
80 mOverrideScalingMode(-1),
81 mCurrentOpacity(true),
82 mCurrentFrameNumber(0),
83 mRefreshPending(false),
84 mFrameLatencyNeeded(false),
85 mFiltering(false),
86 mNeedsFiltering(false),
87 mMesh(Mesh::TRIANGLE_FAN, 4, 2, 2),
88 #ifndef USE_HWC2
89 mIsGlesComposition(false),
90 #endif
91 mProtectedByApp(false),
92 mHasSurface(false),
93 mClientRef(client),
94 mPotentialCursor(false),
95 mQueueItemLock(),
96 mQueueItemCondition(),
97 mQueueItems(),
98 mLastFrameNumberReceived(0),
99 mUpdateTexImageFailed(false),
100 mAutoRefresh(false),
101 mFreezePositionUpdates(false)
102 {
103 #ifdef USE_HWC2
104 ALOGV("Creating Layer %s", name.string());
105 #endif
106
107 mCurrentCrop.makeInvalid();
108 mFlinger->getRenderEngine().genTextures(1, &mTextureName);
109 mTexture.init(Texture::TEXTURE_EXTERNAL, mTextureName);
110
111 uint32_t layerFlags = 0;
112 if (flags & ISurfaceComposerClient::eHidden)
113 layerFlags |= layer_state_t::eLayerHidden;
114 if (flags & ISurfaceComposerClient::eOpaque)
115 layerFlags |= layer_state_t::eLayerOpaque;
116 if (flags & ISurfaceComposerClient::eSecure)
117 layerFlags |= layer_state_t::eLayerSecure;
118
119 if (flags & ISurfaceComposerClient::eNonPremultiplied)
120 mPremultipliedAlpha = false;
121
122 mName = name;
123
124 mCurrentState.active.w = w;
125 mCurrentState.active.h = h;
126 mCurrentState.active.transform.set(0, 0);
127 mCurrentState.crop.makeInvalid();
128 mCurrentState.finalCrop.makeInvalid();
129 mCurrentState.z = 0;
130 #ifdef USE_HWC2
131 mCurrentState.alpha = 1.0f;
132 #else
133 mCurrentState.alpha = 0xFF;
134 #endif
135 mCurrentState.layerStack = 0;
136 mCurrentState.flags = layerFlags;
137 mCurrentState.sequence = 0;
138 mCurrentState.requested = mCurrentState.active;
139
140 // drawing state & current state are identical
141 mDrawingState = mCurrentState;
142
143 #ifdef USE_HWC2
144 const auto& hwc = flinger->getHwComposer();
145 const auto& activeConfig = hwc.getActiveConfig(HWC_DISPLAY_PRIMARY);
146 nsecs_t displayPeriod = activeConfig->getVsyncPeriod();
147 #else
148 nsecs_t displayPeriod =
149 flinger->getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
150 #endif
151 mFrameTracker.setDisplayRefreshPeriod(displayPeriod);
152 }
153
onFirstRef()154 void Layer::onFirstRef() {
155 // Creates a custom BufferQueue for SurfaceFlingerConsumer to use
156 sp<IGraphicBufferProducer> producer;
157 sp<IGraphicBufferConsumer> consumer;
158 BufferQueue::createBufferQueue(&producer, &consumer);
159 mProducer = new MonitoredProducer(producer, mFlinger);
160 mSurfaceFlingerConsumer = new SurfaceFlingerConsumer(consumer, mTextureName,
161 this);
162 mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0));
163 mSurfaceFlingerConsumer->setContentsChangedListener(this);
164 mSurfaceFlingerConsumer->setName(mName);
165
166 #ifdef TARGET_DISABLE_TRIPLE_BUFFERING
167 #warning "disabling triple buffering"
168 #else
169 mProducer->setMaxDequeuedBufferCount(2);
170 #endif
171
172 const sp<const DisplayDevice> hw(mFlinger->getDefaultDisplayDevice());
173 updateTransformHint(hw);
174 }
175
~Layer()176 Layer::~Layer() {
177 sp<Client> c(mClientRef.promote());
178 if (c != 0) {
179 c->detachLayer(this);
180 }
181
182 for (auto& point : mRemoteSyncPoints) {
183 point->setTransactionApplied();
184 }
185 for (auto& point : mLocalSyncPoints) {
186 point->setFrameAvailable();
187 }
188 mFlinger->deleteTextureAsync(mTextureName);
189 mFrameTracker.logAndResetStats(mName);
190 }
191
192 // ---------------------------------------------------------------------------
193 // callbacks
194 // ---------------------------------------------------------------------------
195
196 #ifdef USE_HWC2
onLayerDisplayed(const sp<Fence> & releaseFence)197 void Layer::onLayerDisplayed(const sp<Fence>& releaseFence) {
198 if (mHwcLayers.empty()) {
199 return;
200 }
201 mSurfaceFlingerConsumer->setReleaseFence(releaseFence);
202 }
203 #else
onLayerDisplayed(const sp<const DisplayDevice> &,HWComposer::HWCLayerInterface * layer)204 void Layer::onLayerDisplayed(const sp<const DisplayDevice>& /* hw */,
205 HWComposer::HWCLayerInterface* layer) {
206 if (layer) {
207 layer->onDisplayed();
208 mSurfaceFlingerConsumer->setReleaseFence(layer->getAndResetReleaseFence());
209 }
210 }
211 #endif
212
onFrameAvailable(const BufferItem & item)213 void Layer::onFrameAvailable(const BufferItem& item) {
214 // Add this buffer from our internal queue tracker
215 { // Autolock scope
216 Mutex::Autolock lock(mQueueItemLock);
217
218 // Reset the frame number tracker when we receive the first buffer after
219 // a frame number reset
220 if (item.mFrameNumber == 1) {
221 mLastFrameNumberReceived = 0;
222 }
223
224 // Ensure that callbacks are handled in order
225 while (item.mFrameNumber != mLastFrameNumberReceived + 1) {
226 status_t result = mQueueItemCondition.waitRelative(mQueueItemLock,
227 ms2ns(500));
228 if (result != NO_ERROR) {
229 ALOGE("[%s] Timed out waiting on callback", mName.string());
230 }
231 }
232
233 mQueueItems.push_back(item);
234 android_atomic_inc(&mQueuedFrames);
235
236 // Wake up any pending callbacks
237 mLastFrameNumberReceived = item.mFrameNumber;
238 mQueueItemCondition.broadcast();
239 }
240
241 mFlinger->signalLayerUpdate();
242 }
243
onFrameReplaced(const BufferItem & item)244 void Layer::onFrameReplaced(const BufferItem& item) {
245 { // Autolock scope
246 Mutex::Autolock lock(mQueueItemLock);
247
248 // Ensure that callbacks are handled in order
249 while (item.mFrameNumber != mLastFrameNumberReceived + 1) {
250 status_t result = mQueueItemCondition.waitRelative(mQueueItemLock,
251 ms2ns(500));
252 if (result != NO_ERROR) {
253 ALOGE("[%s] Timed out waiting on callback", mName.string());
254 }
255 }
256
257 if (mQueueItems.empty()) {
258 ALOGE("Can't replace a frame on an empty queue");
259 return;
260 }
261 mQueueItems.editItemAt(mQueueItems.size() - 1) = item;
262
263 // Wake up any pending callbacks
264 mLastFrameNumberReceived = item.mFrameNumber;
265 mQueueItemCondition.broadcast();
266 }
267 }
268
onSidebandStreamChanged()269 void Layer::onSidebandStreamChanged() {
270 if (android_atomic_release_cas(false, true, &mSidebandStreamChanged) == 0) {
271 // mSidebandStreamChanged was false
272 mFlinger->signalLayerUpdate();
273 }
274 }
275
276 // called with SurfaceFlinger::mStateLock from the drawing thread after
277 // the layer has been remove from the current state list (and just before
278 // it's removed from the drawing state list)
onRemoved()279 void Layer::onRemoved() {
280 mSurfaceFlingerConsumer->abandon();
281 }
282
283 // ---------------------------------------------------------------------------
284 // set-up
285 // ---------------------------------------------------------------------------
286
getName() const287 const String8& Layer::getName() const {
288 return mName;
289 }
290
setBuffers(uint32_t w,uint32_t h,PixelFormat format,uint32_t flags)291 status_t Layer::setBuffers( uint32_t w, uint32_t h,
292 PixelFormat format, uint32_t flags)
293 {
294 uint32_t const maxSurfaceDims = min(
295 mFlinger->getMaxTextureSize(), mFlinger->getMaxViewportDims());
296
297 // never allow a surface larger than what our underlying GL implementation
298 // can handle.
299 if ((uint32_t(w)>maxSurfaceDims) || (uint32_t(h)>maxSurfaceDims)) {
300 ALOGE("dimensions too large %u x %u", uint32_t(w), uint32_t(h));
301 return BAD_VALUE;
302 }
303
304 mFormat = format;
305
306 mPotentialCursor = (flags & ISurfaceComposerClient::eCursorWindow) ? true : false;
307 mProtectedByApp = (flags & ISurfaceComposerClient::eProtectedByApp) ? true : false;
308 mCurrentOpacity = getOpacityForFormat(format);
309
310 mSurfaceFlingerConsumer->setDefaultBufferSize(w, h);
311 mSurfaceFlingerConsumer->setDefaultBufferFormat(format);
312 mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0));
313
314 return NO_ERROR;
315 }
316
317 /*
318 * The layer handle is just a BBinder object passed to the client
319 * (remote process) -- we don't keep any reference on our side such that
320 * the dtor is called when the remote side let go of its reference.
321 *
322 * LayerCleaner ensures that mFlinger->onLayerDestroyed() is called for
323 * this layer when the handle is destroyed.
324 */
325 class Layer::Handle : public BBinder, public LayerCleaner {
326 public:
Handle(const sp<SurfaceFlinger> & flinger,const sp<Layer> & layer)327 Handle(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer)
328 : LayerCleaner(flinger, layer), owner(layer) {}
329
330 wp<Layer> owner;
331 };
332
getHandle()333 sp<IBinder> Layer::getHandle() {
334 Mutex::Autolock _l(mLock);
335
336 LOG_ALWAYS_FATAL_IF(mHasSurface,
337 "Layer::getHandle() has already been called");
338
339 mHasSurface = true;
340
341 return new Handle(mFlinger, this);
342 }
343
getProducer() const344 sp<IGraphicBufferProducer> Layer::getProducer() const {
345 return mProducer;
346 }
347
348 // ---------------------------------------------------------------------------
349 // h/w composer set-up
350 // ---------------------------------------------------------------------------
351
getContentCrop() const352 Rect Layer::getContentCrop() const {
353 // this is the crop rectangle that applies to the buffer
354 // itself (as opposed to the window)
355 Rect crop;
356 if (!mCurrentCrop.isEmpty()) {
357 // if the buffer crop is defined, we use that
358 crop = mCurrentCrop;
359 } else if (mActiveBuffer != NULL) {
360 // otherwise we use the whole buffer
361 crop = mActiveBuffer->getBounds();
362 } else {
363 // if we don't have a buffer yet, we use an empty/invalid crop
364 crop.makeInvalid();
365 }
366 return crop;
367 }
368
reduce(const Rect & win,const Region & exclude)369 static Rect reduce(const Rect& win, const Region& exclude) {
370 if (CC_LIKELY(exclude.isEmpty())) {
371 return win;
372 }
373 if (exclude.isRect()) {
374 return win.reduce(exclude.getBounds());
375 }
376 return Region(win).subtract(exclude).getBounds();
377 }
378
computeBounds() const379 Rect Layer::computeBounds() const {
380 const Layer::State& s(getDrawingState());
381 return computeBounds(s.activeTransparentRegion);
382 }
383
computeBounds(const Region & activeTransparentRegion) const384 Rect Layer::computeBounds(const Region& activeTransparentRegion) const {
385 const Layer::State& s(getDrawingState());
386 Rect win(s.active.w, s.active.h);
387
388 if (!s.crop.isEmpty()) {
389 win.intersect(s.crop, &win);
390 }
391 // subtract the transparent region and snap to the bounds
392 return reduce(win, activeTransparentRegion);
393 }
394
computeCrop(const sp<const DisplayDevice> & hw) const395 FloatRect Layer::computeCrop(const sp<const DisplayDevice>& hw) const {
396 // the content crop is the area of the content that gets scaled to the
397 // layer's size.
398 FloatRect crop(getContentCrop());
399
400 // the crop is the area of the window that gets cropped, but not
401 // scaled in any ways.
402 const State& s(getDrawingState());
403
404 // apply the projection's clipping to the window crop in
405 // layerstack space, and convert-back to layer space.
406 // if there are no window scaling involved, this operation will map to full
407 // pixels in the buffer.
408 // FIXME: the 3 lines below can produce slightly incorrect clipping when we have
409 // a viewport clipping and a window transform. we should use floating point to fix this.
410
411 Rect activeCrop(s.active.w, s.active.h);
412 if (!s.crop.isEmpty()) {
413 activeCrop = s.crop;
414 }
415
416 activeCrop = s.active.transform.transform(activeCrop);
417 if (!activeCrop.intersect(hw->getViewport(), &activeCrop)) {
418 activeCrop.clear();
419 }
420 if (!s.finalCrop.isEmpty()) {
421 if(!activeCrop.intersect(s.finalCrop, &activeCrop)) {
422 activeCrop.clear();
423 }
424 }
425 activeCrop = s.active.transform.inverse().transform(activeCrop);
426
427 // This needs to be here as transform.transform(Rect) computes the
428 // transformed rect and then takes the bounding box of the result before
429 // returning. This means
430 // transform.inverse().transform(transform.transform(Rect)) != Rect
431 // in which case we need to make sure the final rect is clipped to the
432 // display bounds.
433 if (!activeCrop.intersect(Rect(s.active.w, s.active.h), &activeCrop)) {
434 activeCrop.clear();
435 }
436
437 // subtract the transparent region and snap to the bounds
438 activeCrop = reduce(activeCrop, s.activeTransparentRegion);
439
440 // Transform the window crop to match the buffer coordinate system,
441 // which means using the inverse of the current transform set on the
442 // SurfaceFlingerConsumer.
443 uint32_t invTransform = mCurrentTransform;
444 if (mSurfaceFlingerConsumer->getTransformToDisplayInverse()) {
445 /*
446 * the code below applies the primary display's inverse transform to the
447 * buffer
448 */
449 uint32_t invTransformOrient =
450 DisplayDevice::getPrimaryDisplayOrientationTransform();
451 // calculate the inverse transform
452 if (invTransformOrient & NATIVE_WINDOW_TRANSFORM_ROT_90) {
453 invTransformOrient ^= NATIVE_WINDOW_TRANSFORM_FLIP_V |
454 NATIVE_WINDOW_TRANSFORM_FLIP_H;
455 }
456 // and apply to the current transform
457 invTransform = (Transform(invTransformOrient) * Transform(invTransform))
458 .getOrientation();
459 }
460
461 int winWidth = s.active.w;
462 int winHeight = s.active.h;
463 if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) {
464 // If the activeCrop has been rotate the ends are rotated but not
465 // the space itself so when transforming ends back we can't rely on
466 // a modification of the axes of rotation. To account for this we
467 // need to reorient the inverse rotation in terms of the current
468 // axes of rotation.
469 bool is_h_flipped = (invTransform & NATIVE_WINDOW_TRANSFORM_FLIP_H) != 0;
470 bool is_v_flipped = (invTransform & NATIVE_WINDOW_TRANSFORM_FLIP_V) != 0;
471 if (is_h_flipped == is_v_flipped) {
472 invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V |
473 NATIVE_WINDOW_TRANSFORM_FLIP_H;
474 }
475 winWidth = s.active.h;
476 winHeight = s.active.w;
477 }
478 const Rect winCrop = activeCrop.transform(
479 invTransform, s.active.w, s.active.h);
480
481 // below, crop is intersected with winCrop expressed in crop's coordinate space
482 float xScale = crop.getWidth() / float(winWidth);
483 float yScale = crop.getHeight() / float(winHeight);
484
485 float insetL = winCrop.left * xScale;
486 float insetT = winCrop.top * yScale;
487 float insetR = (winWidth - winCrop.right ) * xScale;
488 float insetB = (winHeight - winCrop.bottom) * yScale;
489
490 crop.left += insetL;
491 crop.top += insetT;
492 crop.right -= insetR;
493 crop.bottom -= insetB;
494
495 return crop;
496 }
497
498 #ifdef USE_HWC2
setGeometry(const sp<const DisplayDevice> & displayDevice)499 void Layer::setGeometry(const sp<const DisplayDevice>& displayDevice)
500 #else
501 void Layer::setGeometry(
502 const sp<const DisplayDevice>& hw,
503 HWComposer::HWCLayerInterface& layer)
504 #endif
505 {
506 #ifdef USE_HWC2
507 const auto hwcId = displayDevice->getHwcDisplayId();
508 auto& hwcInfo = mHwcLayers[hwcId];
509 #else
510 layer.setDefaultState();
511 #endif
512
513 // enable this layer
514 #ifdef USE_HWC2
515 hwcInfo.forceClientComposition = false;
516
517 if (isSecure() && !displayDevice->isSecure()) {
518 hwcInfo.forceClientComposition = true;
519 }
520
521 auto& hwcLayer = hwcInfo.layer;
522 #else
523 layer.setSkip(false);
524
525 if (isSecure() && !hw->isSecure()) {
526 layer.setSkip(true);
527 }
528 #endif
529
530 // this gives us only the "orientation" component of the transform
531 const State& s(getDrawingState());
532 #ifdef USE_HWC2
533 if (!isOpaque(s) || s.alpha != 1.0f) {
534 auto blendMode = mPremultipliedAlpha ?
535 HWC2::BlendMode::Premultiplied : HWC2::BlendMode::Coverage;
536 auto error = hwcLayer->setBlendMode(blendMode);
537 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set blend mode %s:"
538 " %s (%d)", mName.string(), to_string(blendMode).c_str(),
539 to_string(error).c_str(), static_cast<int32_t>(error));
540 }
541 #else
542 if (!isOpaque(s) || s.alpha != 0xFF) {
543 layer.setBlending(mPremultipliedAlpha ?
544 HWC_BLENDING_PREMULT :
545 HWC_BLENDING_COVERAGE);
546 }
547 #endif
548
549 // apply the layer's transform, followed by the display's global transform
550 // here we're guaranteed that the layer's transform preserves rects
551 Region activeTransparentRegion(s.activeTransparentRegion);
552 if (!s.crop.isEmpty()) {
553 Rect activeCrop(s.crop);
554 activeCrop = s.active.transform.transform(activeCrop);
555 #ifdef USE_HWC2
556 if(!activeCrop.intersect(displayDevice->getViewport(), &activeCrop)) {
557 #else
558 if(!activeCrop.intersect(hw->getViewport(), &activeCrop)) {
559 #endif
560 activeCrop.clear();
561 }
562 activeCrop = s.active.transform.inverse().transform(activeCrop, true);
563 // This needs to be here as transform.transform(Rect) computes the
564 // transformed rect and then takes the bounding box of the result before
565 // returning. This means
566 // transform.inverse().transform(transform.transform(Rect)) != Rect
567 // in which case we need to make sure the final rect is clipped to the
568 // display bounds.
569 if(!activeCrop.intersect(Rect(s.active.w, s.active.h), &activeCrop)) {
570 activeCrop.clear();
571 }
572 // mark regions outside the crop as transparent
573 activeTransparentRegion.orSelf(Rect(0, 0, s.active.w, activeCrop.top));
574 activeTransparentRegion.orSelf(Rect(0, activeCrop.bottom,
575 s.active.w, s.active.h));
576 activeTransparentRegion.orSelf(Rect(0, activeCrop.top,
577 activeCrop.left, activeCrop.bottom));
578 activeTransparentRegion.orSelf(Rect(activeCrop.right, activeCrop.top,
579 s.active.w, activeCrop.bottom));
580 }
581 Rect frame(s.active.transform.transform(computeBounds(activeTransparentRegion)));
582 if (!s.finalCrop.isEmpty()) {
583 if(!frame.intersect(s.finalCrop, &frame)) {
584 frame.clear();
585 }
586 }
587 #ifdef USE_HWC2
588 if (!frame.intersect(displayDevice->getViewport(), &frame)) {
589 frame.clear();
590 }
591 const Transform& tr(displayDevice->getTransform());
592 Rect transformedFrame = tr.transform(frame);
593 auto error = hwcLayer->setDisplayFrame(transformedFrame);
594 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set display frame "
595 "[%d, %d, %d, %d]: %s (%d)", mName.string(), transformedFrame.left,
596 transformedFrame.top, transformedFrame.right,
597 transformedFrame.bottom, to_string(error).c_str(),
598 static_cast<int32_t>(error));
599
600 FloatRect sourceCrop = computeCrop(displayDevice);
601 error = hwcLayer->setSourceCrop(sourceCrop);
602 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set source crop "
603 "[%.3f, %.3f, %.3f, %.3f]: %s (%d)", mName.string(),
604 sourceCrop.left, sourceCrop.top, sourceCrop.right,
605 sourceCrop.bottom, to_string(error).c_str(),
606 static_cast<int32_t>(error));
607
608 error = hwcLayer->setPlaneAlpha(s.alpha);
609 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set plane alpha %.3f: "
610 "%s (%d)", mName.string(), s.alpha, to_string(error).c_str(),
611 static_cast<int32_t>(error));
612
613 error = hwcLayer->setZOrder(s.z);
614 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set Z %u: %s (%d)",
615 mName.string(), s.z, to_string(error).c_str(),
616 static_cast<int32_t>(error));
617 #else
618 if (!frame.intersect(hw->getViewport(), &frame)) {
619 frame.clear();
620 }
621 const Transform& tr(hw->getTransform());
622 layer.setFrame(tr.transform(frame));
623 layer.setCrop(computeCrop(hw));
624 layer.setPlaneAlpha(s.alpha);
625 #endif
626
627 /*
628 * Transformations are applied in this order:
629 * 1) buffer orientation/flip/mirror
630 * 2) state transformation (window manager)
631 * 3) layer orientation (screen orientation)
632 * (NOTE: the matrices are multiplied in reverse order)
633 */
634
635 const Transform bufferOrientation(mCurrentTransform);
636 Transform transform(tr * s.active.transform * bufferOrientation);
637
638 if (mSurfaceFlingerConsumer->getTransformToDisplayInverse()) {
639 /*
640 * the code below applies the primary display's inverse transform to the
641 * buffer
642 */
643 uint32_t invTransform =
644 DisplayDevice::getPrimaryDisplayOrientationTransform();
645 // calculate the inverse transform
646 if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) {
647 invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V |
648 NATIVE_WINDOW_TRANSFORM_FLIP_H;
649 }
650 // and apply to the current transform
651 transform = Transform(invTransform) * transform;
652 }
653
654 // this gives us only the "orientation" component of the transform
655 const uint32_t orientation = transform.getOrientation();
656 #ifdef USE_HWC2
657 if (orientation & Transform::ROT_INVALID) {
658 // we can only handle simple transformation
659 hwcInfo.forceClientComposition = true;
660 } else {
661 auto transform = static_cast<HWC2::Transform>(orientation);
662 auto error = hwcLayer->setTransform(transform);
663 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set transform %s: "
664 "%s (%d)", mName.string(), to_string(transform).c_str(),
665 to_string(error).c_str(), static_cast<int32_t>(error));
666 }
667 #else
668 if (orientation & Transform::ROT_INVALID) {
669 // we can only handle simple transformation
670 layer.setSkip(true);
671 } else {
672 layer.setTransform(orientation);
673 }
674 #endif
675 }
676
677 #ifdef USE_HWC2
678 void Layer::forceClientComposition(int32_t hwcId) {
679 if (mHwcLayers.count(hwcId) == 0) {
680 ALOGE("forceClientComposition: no HWC layer found (%d)", hwcId);
681 return;
682 }
683
684 mHwcLayers[hwcId].forceClientComposition = true;
685 }
686 #endif
687
688 #ifdef USE_HWC2
689 void Layer::setPerFrameData(const sp<const DisplayDevice>& displayDevice) {
690 // Apply this display's projection's viewport to the visible region
691 // before giving it to the HWC HAL.
692 const Transform& tr = displayDevice->getTransform();
693 const auto& viewport = displayDevice->getViewport();
694 Region visible = tr.transform(visibleRegion.intersect(viewport));
695 auto hwcId = displayDevice->getHwcDisplayId();
696 auto& hwcLayer = mHwcLayers[hwcId].layer;
697 auto error = hwcLayer->setVisibleRegion(visible);
698 if (error != HWC2::Error::None) {
699 ALOGE("[%s] Failed to set visible region: %s (%d)", mName.string(),
700 to_string(error).c_str(), static_cast<int32_t>(error));
701 visible.dump(LOG_TAG);
702 }
703
704 error = hwcLayer->setSurfaceDamage(surfaceDamageRegion);
705 if (error != HWC2::Error::None) {
706 ALOGE("[%s] Failed to set surface damage: %s (%d)", mName.string(),
707 to_string(error).c_str(), static_cast<int32_t>(error));
708 surfaceDamageRegion.dump(LOG_TAG);
709 }
710
711 // Sideband layers
712 if (mSidebandStream.get()) {
713 setCompositionType(hwcId, HWC2::Composition::Sideband);
714 ALOGV("[%s] Requesting Sideband composition", mName.string());
715 error = hwcLayer->setSidebandStream(mSidebandStream->handle());
716 if (error != HWC2::Error::None) {
717 ALOGE("[%s] Failed to set sideband stream %p: %s (%d)",
718 mName.string(), mSidebandStream->handle(),
719 to_string(error).c_str(), static_cast<int32_t>(error));
720 }
721 return;
722 }
723
724 // Client layers
725 if (mHwcLayers[hwcId].forceClientComposition ||
726 (mActiveBuffer != nullptr && mActiveBuffer->handle == nullptr)) {
727 ALOGV("[%s] Requesting Client composition", mName.string());
728 setCompositionType(hwcId, HWC2::Composition::Client);
729 return;
730 }
731
732 // SolidColor layers
733 if (mActiveBuffer == nullptr) {
734 setCompositionType(hwcId, HWC2::Composition::SolidColor);
735
736 // For now, we only support black for DimLayer
737 error = hwcLayer->setColor({0, 0, 0, 255});
738 if (error != HWC2::Error::None) {
739 ALOGE("[%s] Failed to set color: %s (%d)", mName.string(),
740 to_string(error).c_str(), static_cast<int32_t>(error));
741 }
742
743 // Clear out the transform, because it doesn't make sense absent a
744 // source buffer
745 error = hwcLayer->setTransform(HWC2::Transform::None);
746 if (error != HWC2::Error::None) {
747 ALOGE("[%s] Failed to clear transform: %s (%d)", mName.string(),
748 to_string(error).c_str(), static_cast<int32_t>(error));
749 }
750
751 return;
752 }
753
754 // Device or Cursor layers
755 if (mPotentialCursor) {
756 ALOGV("[%s] Requesting Cursor composition", mName.string());
757 setCompositionType(hwcId, HWC2::Composition::Cursor);
758 } else {
759 ALOGV("[%s] Requesting Device composition", mName.string());
760 setCompositionType(hwcId, HWC2::Composition::Device);
761 }
762
763 auto acquireFence = mSurfaceFlingerConsumer->getCurrentFence();
764 error = hwcLayer->setBuffer(mActiveBuffer->handle, acquireFence);
765 if (error != HWC2::Error::None) {
766 ALOGE("[%s] Failed to set buffer %p: %s (%d)", mName.string(),
767 mActiveBuffer->handle, to_string(error).c_str(),
768 static_cast<int32_t>(error));
769 }
770 }
771 #else
772 void Layer::setPerFrameData(const sp<const DisplayDevice>& hw,
773 HWComposer::HWCLayerInterface& layer) {
774 // we have to set the visible region on every frame because
775 // we currently free it during onLayerDisplayed(), which is called
776 // after HWComposer::commit() -- every frame.
777 // Apply this display's projection's viewport to the visible region
778 // before giving it to the HWC HAL.
779 const Transform& tr = hw->getTransform();
780 Region visible = tr.transform(visibleRegion.intersect(hw->getViewport()));
781 layer.setVisibleRegionScreen(visible);
782 layer.setSurfaceDamage(surfaceDamageRegion);
783 mIsGlesComposition = (layer.getCompositionType() == HWC_FRAMEBUFFER);
784
785 if (mSidebandStream.get()) {
786 layer.setSidebandStream(mSidebandStream);
787 } else {
788 // NOTE: buffer can be NULL if the client never drew into this
789 // layer yet, or if we ran out of memory
790 layer.setBuffer(mActiveBuffer);
791 }
792 }
793 #endif
794
795 #ifdef USE_HWC2
796 void Layer::updateCursorPosition(const sp<const DisplayDevice>& displayDevice) {
797 auto hwcId = displayDevice->getHwcDisplayId();
798 if (mHwcLayers.count(hwcId) == 0 ||
799 getCompositionType(hwcId) != HWC2::Composition::Cursor) {
800 return;
801 }
802
803 // This gives us only the "orientation" component of the transform
804 const State& s(getCurrentState());
805
806 // Apply the layer's transform, followed by the display's global transform
807 // Here we're guaranteed that the layer's transform preserves rects
808 Rect win(s.active.w, s.active.h);
809 if (!s.crop.isEmpty()) {
810 win.intersect(s.crop, &win);
811 }
812 // Subtract the transparent region and snap to the bounds
813 Rect bounds = reduce(win, s.activeTransparentRegion);
814 Rect frame(s.active.transform.transform(bounds));
815 frame.intersect(displayDevice->getViewport(), &frame);
816 if (!s.finalCrop.isEmpty()) {
817 frame.intersect(s.finalCrop, &frame);
818 }
819 auto& displayTransform(displayDevice->getTransform());
820 auto position = displayTransform.transform(frame);
821
822 auto error = mHwcLayers[hwcId].layer->setCursorPosition(position.left,
823 position.top);
824 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set cursor position "
825 "to (%d, %d): %s (%d)", mName.string(), position.left,
826 position.top, to_string(error).c_str(),
827 static_cast<int32_t>(error));
828 }
829 #else
830 void Layer::setAcquireFence(const sp<const DisplayDevice>& /* hw */,
831 HWComposer::HWCLayerInterface& layer) {
832 int fenceFd = -1;
833
834 // TODO: there is a possible optimization here: we only need to set the
835 // acquire fence the first time a new buffer is acquired on EACH display.
836
837 if (layer.getCompositionType() == HWC_OVERLAY || layer.getCompositionType() == HWC_CURSOR_OVERLAY) {
838 sp<Fence> fence = mSurfaceFlingerConsumer->getCurrentFence();
839 if (fence->isValid()) {
840 fenceFd = fence->dup();
841 if (fenceFd == -1) {
842 ALOGW("failed to dup layer fence, skipping sync: %d", errno);
843 }
844 }
845 }
846 layer.setAcquireFenceFd(fenceFd);
847 }
848
849 Rect Layer::getPosition(
850 const sp<const DisplayDevice>& hw)
851 {
852 // this gives us only the "orientation" component of the transform
853 const State& s(getCurrentState());
854
855 // apply the layer's transform, followed by the display's global transform
856 // here we're guaranteed that the layer's transform preserves rects
857 Rect win(s.active.w, s.active.h);
858 if (!s.crop.isEmpty()) {
859 win.intersect(s.crop, &win);
860 }
861 // subtract the transparent region and snap to the bounds
862 Rect bounds = reduce(win, s.activeTransparentRegion);
863 Rect frame(s.active.transform.transform(bounds));
864 frame.intersect(hw->getViewport(), &frame);
865 if (!s.finalCrop.isEmpty()) {
866 frame.intersect(s.finalCrop, &frame);
867 }
868 const Transform& tr(hw->getTransform());
869 return Rect(tr.transform(frame));
870 }
871 #endif
872
873 // ---------------------------------------------------------------------------
874 // drawing...
875 // ---------------------------------------------------------------------------
876
877 void Layer::draw(const sp<const DisplayDevice>& hw, const Region& clip) const {
878 onDraw(hw, clip, false);
879 }
880
881 void Layer::draw(const sp<const DisplayDevice>& hw,
882 bool useIdentityTransform) const {
883 onDraw(hw, Region(hw->bounds()), useIdentityTransform);
884 }
885
886 void Layer::draw(const sp<const DisplayDevice>& hw) const {
887 onDraw(hw, Region(hw->bounds()), false);
888 }
889
890 void Layer::onDraw(const sp<const DisplayDevice>& hw, const Region& clip,
891 bool useIdentityTransform) const
892 {
893 ATRACE_CALL();
894
895 if (CC_UNLIKELY(mActiveBuffer == 0)) {
896 // the texture has not been created yet, this Layer has
897 // in fact never been drawn into. This happens frequently with
898 // SurfaceView because the WindowManager can't know when the client
899 // has drawn the first time.
900
901 // If there is nothing under us, we paint the screen in black, otherwise
902 // we just skip this update.
903
904 // figure out if there is something below us
905 Region under;
906 const SurfaceFlinger::LayerVector& drawingLayers(
907 mFlinger->mDrawingState.layersSortedByZ);
908 const size_t count = drawingLayers.size();
909 for (size_t i=0 ; i<count ; ++i) {
910 const sp<Layer>& layer(drawingLayers[i]);
911 if (layer.get() == static_cast<Layer const*>(this))
912 break;
913 under.orSelf( hw->getTransform().transform(layer->visibleRegion) );
914 }
915 // if not everything below us is covered, we plug the holes!
916 Region holes(clip.subtract(under));
917 if (!holes.isEmpty()) {
918 clearWithOpenGL(hw, holes, 0, 0, 0, 1);
919 }
920 return;
921 }
922
923 // Bind the current buffer to the GL texture, and wait for it to be
924 // ready for us to draw into.
925 status_t err = mSurfaceFlingerConsumer->bindTextureImage();
926 if (err != NO_ERROR) {
927 ALOGW("onDraw: bindTextureImage failed (err=%d)", err);
928 // Go ahead and draw the buffer anyway; no matter what we do the screen
929 // is probably going to have something visibly wrong.
930 }
931
932 bool blackOutLayer = isProtected() || (isSecure() && !hw->isSecure());
933
934 RenderEngine& engine(mFlinger->getRenderEngine());
935
936 if (!blackOutLayer) {
937 // TODO: we could be more subtle with isFixedSize()
938 const bool useFiltering = getFiltering() || needsFiltering(hw) || isFixedSize();
939
940 // Query the texture matrix given our current filtering mode.
941 float textureMatrix[16];
942 mSurfaceFlingerConsumer->setFilteringEnabled(useFiltering);
943 mSurfaceFlingerConsumer->getTransformMatrix(textureMatrix);
944
945 if (mSurfaceFlingerConsumer->getTransformToDisplayInverse()) {
946
947 /*
948 * the code below applies the primary display's inverse transform to
949 * the texture transform
950 */
951
952 // create a 4x4 transform matrix from the display transform flags
953 const mat4 flipH(-1,0,0,0, 0,1,0,0, 0,0,1,0, 1,0,0,1);
954 const mat4 flipV( 1,0,0,0, 0,-1,0,0, 0,0,1,0, 0,1,0,1);
955 const mat4 rot90( 0,1,0,0, -1,0,0,0, 0,0,1,0, 1,0,0,1);
956
957 mat4 tr;
958 uint32_t transform =
959 DisplayDevice::getPrimaryDisplayOrientationTransform();
960 if (transform & NATIVE_WINDOW_TRANSFORM_ROT_90)
961 tr = tr * rot90;
962 if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_H)
963 tr = tr * flipH;
964 if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_V)
965 tr = tr * flipV;
966
967 // calculate the inverse
968 tr = inverse(tr);
969
970 // and finally apply it to the original texture matrix
971 const mat4 texTransform(mat4(static_cast<const float*>(textureMatrix)) * tr);
972 memcpy(textureMatrix, texTransform.asArray(), sizeof(textureMatrix));
973 }
974
975 // Set things up for texturing.
976 mTexture.setDimensions(mActiveBuffer->getWidth(), mActiveBuffer->getHeight());
977 mTexture.setFiltering(useFiltering);
978 mTexture.setMatrix(textureMatrix);
979
980 engine.setupLayerTexturing(mTexture);
981 } else {
982 engine.setupLayerBlackedOut();
983 }
984 drawWithOpenGL(hw, clip, useIdentityTransform);
985 engine.disableTexturing();
986 }
987
988
989 void Layer::clearWithOpenGL(const sp<const DisplayDevice>& hw,
990 const Region& /* clip */, float red, float green, float blue,
991 float alpha) const
992 {
993 RenderEngine& engine(mFlinger->getRenderEngine());
994 computeGeometry(hw, mMesh, false);
995 engine.setupFillWithColor(red, green, blue, alpha);
996 engine.drawMesh(mMesh);
997 }
998
999 void Layer::clearWithOpenGL(
1000 const sp<const DisplayDevice>& hw, const Region& clip) const {
1001 clearWithOpenGL(hw, clip, 0,0,0,0);
1002 }
1003
1004 void Layer::drawWithOpenGL(const sp<const DisplayDevice>& hw,
1005 const Region& /* clip */, bool useIdentityTransform) const {
1006 const State& s(getDrawingState());
1007
1008 computeGeometry(hw, mMesh, useIdentityTransform);
1009
1010 /*
1011 * NOTE: the way we compute the texture coordinates here produces
1012 * different results than when we take the HWC path -- in the later case
1013 * the "source crop" is rounded to texel boundaries.
1014 * This can produce significantly different results when the texture
1015 * is scaled by a large amount.
1016 *
1017 * The GL code below is more logical (imho), and the difference with
1018 * HWC is due to a limitation of the HWC API to integers -- a question
1019 * is suspend is whether we should ignore this problem or revert to
1020 * GL composition when a buffer scaling is applied (maybe with some
1021 * minimal value)? Or, we could make GL behave like HWC -- but this feel
1022 * like more of a hack.
1023 */
1024 Rect win(computeBounds());
1025
1026 if (!s.finalCrop.isEmpty()) {
1027 win = s.active.transform.transform(win);
1028 if (!win.intersect(s.finalCrop, &win)) {
1029 win.clear();
1030 }
1031 win = s.active.transform.inverse().transform(win);
1032 if (!win.intersect(computeBounds(), &win)) {
1033 win.clear();
1034 }
1035 }
1036
1037 float left = float(win.left) / float(s.active.w);
1038 float top = float(win.top) / float(s.active.h);
1039 float right = float(win.right) / float(s.active.w);
1040 float bottom = float(win.bottom) / float(s.active.h);
1041
1042 // TODO: we probably want to generate the texture coords with the mesh
1043 // here we assume that we only have 4 vertices
1044 Mesh::VertexArray<vec2> texCoords(mMesh.getTexCoordArray<vec2>());
1045 texCoords[0] = vec2(left, 1.0f - top);
1046 texCoords[1] = vec2(left, 1.0f - bottom);
1047 texCoords[2] = vec2(right, 1.0f - bottom);
1048 texCoords[3] = vec2(right, 1.0f - top);
1049
1050 RenderEngine& engine(mFlinger->getRenderEngine());
1051 engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(s), s.alpha);
1052 engine.drawMesh(mMesh);
1053 engine.disableBlending();
1054 }
1055
1056 #ifdef USE_HWC2
1057 void Layer::setCompositionType(int32_t hwcId, HWC2::Composition type,
1058 bool callIntoHwc) {
1059 if (mHwcLayers.count(hwcId) == 0) {
1060 ALOGE("setCompositionType called without a valid HWC layer");
1061 return;
1062 }
1063 auto& hwcInfo = mHwcLayers[hwcId];
1064 auto& hwcLayer = hwcInfo.layer;
1065 ALOGV("setCompositionType(%" PRIx64 ", %s, %d)", hwcLayer->getId(),
1066 to_string(type).c_str(), static_cast<int>(callIntoHwc));
1067 if (hwcInfo.compositionType != type) {
1068 ALOGV(" actually setting");
1069 hwcInfo.compositionType = type;
1070 if (callIntoHwc) {
1071 auto error = hwcLayer->setCompositionType(type);
1072 ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set "
1073 "composition type %s: %s (%d)", mName.string(),
1074 to_string(type).c_str(), to_string(error).c_str(),
1075 static_cast<int32_t>(error));
1076 }
1077 }
1078 }
1079
1080 HWC2::Composition Layer::getCompositionType(int32_t hwcId) const {
1081 if (hwcId == DisplayDevice::DISPLAY_ID_INVALID) {
1082 // If we're querying the composition type for a display that does not
1083 // have a HWC counterpart, then it will always be Client
1084 return HWC2::Composition::Client;
1085 }
1086 if (mHwcLayers.count(hwcId) == 0) {
1087 ALOGE("getCompositionType called with an invalid HWC layer");
1088 return HWC2::Composition::Invalid;
1089 }
1090 return mHwcLayers.at(hwcId).compositionType;
1091 }
1092
1093 void Layer::setClearClientTarget(int32_t hwcId, bool clear) {
1094 if (mHwcLayers.count(hwcId) == 0) {
1095 ALOGE("setClearClientTarget called without a valid HWC layer");
1096 return;
1097 }
1098 mHwcLayers[hwcId].clearClientTarget = clear;
1099 }
1100
1101 bool Layer::getClearClientTarget(int32_t hwcId) const {
1102 if (mHwcLayers.count(hwcId) == 0) {
1103 ALOGE("getClearClientTarget called without a valid HWC layer");
1104 return false;
1105 }
1106 return mHwcLayers.at(hwcId).clearClientTarget;
1107 }
1108 #endif
1109
1110 uint32_t Layer::getProducerStickyTransform() const {
1111 int producerStickyTransform = 0;
1112 int ret = mProducer->query(NATIVE_WINDOW_STICKY_TRANSFORM, &producerStickyTransform);
1113 if (ret != OK) {
1114 ALOGW("%s: Error %s (%d) while querying window sticky transform.", __FUNCTION__,
1115 strerror(-ret), ret);
1116 return 0;
1117 }
1118 return static_cast<uint32_t>(producerStickyTransform);
1119 }
1120
1121 bool Layer::latchUnsignaledBuffers() {
1122 static bool propertyLoaded = false;
1123 static bool latch = false;
1124 static std::mutex mutex;
1125 std::lock_guard<std::mutex> lock(mutex);
1126 if (!propertyLoaded) {
1127 char value[PROPERTY_VALUE_MAX] = {};
1128 property_get("debug.sf.latch_unsignaled", value, "0");
1129 latch = atoi(value);
1130 propertyLoaded = true;
1131 }
1132 return latch;
1133 }
1134
1135 uint64_t Layer::getHeadFrameNumber() const {
1136 Mutex::Autolock lock(mQueueItemLock);
1137 if (!mQueueItems.empty()) {
1138 return mQueueItems[0].mFrameNumber;
1139 } else {
1140 return mCurrentFrameNumber;
1141 }
1142 }
1143
1144 bool Layer::headFenceHasSignaled() const {
1145 #ifdef USE_HWC2
1146 if (latchUnsignaledBuffers()) {
1147 return true;
1148 }
1149
1150 Mutex::Autolock lock(mQueueItemLock);
1151 if (mQueueItems.empty()) {
1152 return true;
1153 }
1154 if (mQueueItems[0].mIsDroppable) {
1155 // Even though this buffer's fence may not have signaled yet, it could
1156 // be replaced by another buffer before it has a chance to, which means
1157 // that it's possible to get into a situation where a buffer is never
1158 // able to be latched. To avoid this, grab this buffer anyway.
1159 return true;
1160 }
1161 return mQueueItems[0].mFence->getSignalTime() != INT64_MAX;
1162 #else
1163 return true;
1164 #endif
1165 }
1166
1167 bool Layer::addSyncPoint(const std::shared_ptr<SyncPoint>& point) {
1168 if (point->getFrameNumber() <= mCurrentFrameNumber) {
1169 // Don't bother with a SyncPoint, since we've already latched the
1170 // relevant frame
1171 return false;
1172 }
1173
1174 Mutex::Autolock lock(mLocalSyncPointMutex);
1175 mLocalSyncPoints.push_back(point);
1176 return true;
1177 }
1178
1179 void Layer::setFiltering(bool filtering) {
1180 mFiltering = filtering;
1181 }
1182
1183 bool Layer::getFiltering() const {
1184 return mFiltering;
1185 }
1186
1187 // As documented in libhardware header, formats in the range
1188 // 0x100 - 0x1FF are specific to the HAL implementation, and
1189 // are known to have no alpha channel
1190 // TODO: move definition for device-specific range into
1191 // hardware.h, instead of using hard-coded values here.
1192 #define HARDWARE_IS_DEVICE_FORMAT(f) ((f) >= 0x100 && (f) <= 0x1FF)
1193
1194 bool Layer::getOpacityForFormat(uint32_t format) {
1195 if (HARDWARE_IS_DEVICE_FORMAT(format)) {
1196 return true;
1197 }
1198 switch (format) {
1199 case HAL_PIXEL_FORMAT_RGBA_8888:
1200 case HAL_PIXEL_FORMAT_BGRA_8888:
1201 return false;
1202 }
1203 // in all other case, we have no blending (also for unknown formats)
1204 return true;
1205 }
1206
1207 // ----------------------------------------------------------------------------
1208 // local state
1209 // ----------------------------------------------------------------------------
1210
1211 static void boundPoint(vec2* point, const Rect& crop) {
1212 if (point->x < crop.left) {
1213 point->x = crop.left;
1214 }
1215 if (point->x > crop.right) {
1216 point->x = crop.right;
1217 }
1218 if (point->y < crop.top) {
1219 point->y = crop.top;
1220 }
1221 if (point->y > crop.bottom) {
1222 point->y = crop.bottom;
1223 }
1224 }
1225
1226 void Layer::computeGeometry(const sp<const DisplayDevice>& hw, Mesh& mesh,
1227 bool useIdentityTransform) const
1228 {
1229 const Layer::State& s(getDrawingState());
1230 const Transform tr(hw->getTransform());
1231 const uint32_t hw_h = hw->getHeight();
1232 Rect win(s.active.w, s.active.h);
1233 if (!s.crop.isEmpty()) {
1234 win.intersect(s.crop, &win);
1235 }
1236 // subtract the transparent region and snap to the bounds
1237 win = reduce(win, s.activeTransparentRegion);
1238
1239 vec2 lt = vec2(win.left, win.top);
1240 vec2 lb = vec2(win.left, win.bottom);
1241 vec2 rb = vec2(win.right, win.bottom);
1242 vec2 rt = vec2(win.right, win.top);
1243
1244 if (!useIdentityTransform) {
1245 lt = s.active.transform.transform(lt);
1246 lb = s.active.transform.transform(lb);
1247 rb = s.active.transform.transform(rb);
1248 rt = s.active.transform.transform(rt);
1249 }
1250
1251 if (!s.finalCrop.isEmpty()) {
1252 boundPoint(<, s.finalCrop);
1253 boundPoint(&lb, s.finalCrop);
1254 boundPoint(&rb, s.finalCrop);
1255 boundPoint(&rt, s.finalCrop);
1256 }
1257
1258 Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());
1259 position[0] = tr.transform(lt);
1260 position[1] = tr.transform(lb);
1261 position[2] = tr.transform(rb);
1262 position[3] = tr.transform(rt);
1263 for (size_t i=0 ; i<4 ; i++) {
1264 position[i].y = hw_h - position[i].y;
1265 }
1266 }
1267
1268 bool Layer::isOpaque(const Layer::State& s) const
1269 {
1270 // if we don't have a buffer yet, we're translucent regardless of the
1271 // layer's opaque flag.
1272 if (mActiveBuffer == 0) {
1273 return false;
1274 }
1275
1276 // if the layer has the opaque flag, then we're always opaque,
1277 // otherwise we use the current buffer's format.
1278 return ((s.flags & layer_state_t::eLayerOpaque) != 0) || mCurrentOpacity;
1279 }
1280
1281 bool Layer::isSecure() const
1282 {
1283 const Layer::State& s(mDrawingState);
1284 return (s.flags & layer_state_t::eLayerSecure);
1285 }
1286
1287 bool Layer::isProtected() const
1288 {
1289 const sp<GraphicBuffer>& activeBuffer(mActiveBuffer);
1290 return (activeBuffer != 0) &&
1291 (activeBuffer->getUsage() & GRALLOC_USAGE_PROTECTED);
1292 }
1293
1294 bool Layer::isFixedSize() const {
1295 return getEffectiveScalingMode() != NATIVE_WINDOW_SCALING_MODE_FREEZE;
1296 }
1297
1298 bool Layer::isCropped() const {
1299 return !mCurrentCrop.isEmpty();
1300 }
1301
1302 bool Layer::needsFiltering(const sp<const DisplayDevice>& hw) const {
1303 return mNeedsFiltering || hw->needsFiltering();
1304 }
1305
1306 void Layer::setVisibleRegion(const Region& visibleRegion) {
1307 // always called from main thread
1308 this->visibleRegion = visibleRegion;
1309 }
1310
1311 void Layer::setCoveredRegion(const Region& coveredRegion) {
1312 // always called from main thread
1313 this->coveredRegion = coveredRegion;
1314 }
1315
1316 void Layer::setVisibleNonTransparentRegion(const Region&
1317 setVisibleNonTransparentRegion) {
1318 // always called from main thread
1319 this->visibleNonTransparentRegion = setVisibleNonTransparentRegion;
1320 }
1321
1322 // ----------------------------------------------------------------------------
1323 // transaction
1324 // ----------------------------------------------------------------------------
1325
1326 void Layer::pushPendingState() {
1327 if (!mCurrentState.modified) {
1328 return;
1329 }
1330
1331 // If this transaction is waiting on the receipt of a frame, generate a sync
1332 // point and send it to the remote layer.
1333 if (mCurrentState.handle != nullptr) {
1334 sp<IBinder> strongBinder = mCurrentState.handle.promote();
1335 sp<Handle> handle = nullptr;
1336 sp<Layer> handleLayer = nullptr;
1337 if (strongBinder != nullptr) {
1338 handle = static_cast<Handle*>(strongBinder.get());
1339 handleLayer = handle->owner.promote();
1340 }
1341 if (strongBinder == nullptr || handleLayer == nullptr) {
1342 ALOGE("[%s] Unable to promote Layer handle", mName.string());
1343 // If we can't promote the layer we are intended to wait on,
1344 // then it is expired or otherwise invalid. Allow this transaction
1345 // to be applied as per normal (no synchronization).
1346 mCurrentState.handle = nullptr;
1347 } else {
1348 auto syncPoint = std::make_shared<SyncPoint>(
1349 mCurrentState.frameNumber);
1350 if (handleLayer->addSyncPoint(syncPoint)) {
1351 mRemoteSyncPoints.push_back(std::move(syncPoint));
1352 } else {
1353 // We already missed the frame we're supposed to synchronize
1354 // on, so go ahead and apply the state update
1355 mCurrentState.handle = nullptr;
1356 }
1357 }
1358
1359 // Wake us up to check if the frame has been received
1360 setTransactionFlags(eTransactionNeeded);
1361 }
1362 mPendingStates.push_back(mCurrentState);
1363 }
1364
1365 void Layer::popPendingState(State* stateToCommit) {
1366 auto oldFlags = stateToCommit->flags;
1367 *stateToCommit = mPendingStates[0];
1368 stateToCommit->flags = (oldFlags & ~stateToCommit->mask) |
1369 (stateToCommit->flags & stateToCommit->mask);
1370
1371 mPendingStates.removeAt(0);
1372 }
1373
1374 bool Layer::applyPendingStates(State* stateToCommit) {
1375 bool stateUpdateAvailable = false;
1376 while (!mPendingStates.empty()) {
1377 if (mPendingStates[0].handle != nullptr) {
1378 if (mRemoteSyncPoints.empty()) {
1379 // If we don't have a sync point for this, apply it anyway. It
1380 // will be visually wrong, but it should keep us from getting
1381 // into too much trouble.
1382 ALOGE("[%s] No local sync point found", mName.string());
1383 popPendingState(stateToCommit);
1384 stateUpdateAvailable = true;
1385 continue;
1386 }
1387
1388 if (mRemoteSyncPoints.front()->getFrameNumber() !=
1389 mPendingStates[0].frameNumber) {
1390 ALOGE("[%s] Unexpected sync point frame number found",
1391 mName.string());
1392
1393 // Signal our end of the sync point and then dispose of it
1394 mRemoteSyncPoints.front()->setTransactionApplied();
1395 mRemoteSyncPoints.pop_front();
1396 continue;
1397 }
1398
1399 if (mRemoteSyncPoints.front()->frameIsAvailable()) {
1400 // Apply the state update
1401 popPendingState(stateToCommit);
1402 stateUpdateAvailable = true;
1403
1404 // Signal our end of the sync point and then dispose of it
1405 mRemoteSyncPoints.front()->setTransactionApplied();
1406 mRemoteSyncPoints.pop_front();
1407 } else {
1408 break;
1409 }
1410 } else {
1411 popPendingState(stateToCommit);
1412 stateUpdateAvailable = true;
1413 }
1414 }
1415
1416 // If we still have pending updates, wake SurfaceFlinger back up and point
1417 // it at this layer so we can process them
1418 if (!mPendingStates.empty()) {
1419 setTransactionFlags(eTransactionNeeded);
1420 mFlinger->setTransactionFlags(eTraversalNeeded);
1421 }
1422
1423 mCurrentState.modified = false;
1424 return stateUpdateAvailable;
1425 }
1426
1427 void Layer::notifyAvailableFrames() {
1428 auto headFrameNumber = getHeadFrameNumber();
1429 bool headFenceSignaled = headFenceHasSignaled();
1430 Mutex::Autolock lock(mLocalSyncPointMutex);
1431 for (auto& point : mLocalSyncPoints) {
1432 if (headFrameNumber >= point->getFrameNumber() && headFenceSignaled) {
1433 point->setFrameAvailable();
1434 }
1435 }
1436 }
1437
1438 uint32_t Layer::doTransaction(uint32_t flags) {
1439 ATRACE_CALL();
1440
1441 pushPendingState();
1442 Layer::State c = getCurrentState();
1443 if (!applyPendingStates(&c)) {
1444 return 0;
1445 }
1446
1447 const Layer::State& s(getDrawingState());
1448
1449 const bool sizeChanged = (c.requested.w != s.requested.w) ||
1450 (c.requested.h != s.requested.h);
1451
1452 if (sizeChanged) {
1453 // the size changed, we need to ask our client to request a new buffer
1454 ALOGD_IF(DEBUG_RESIZE,
1455 "doTransaction: geometry (layer=%p '%s'), tr=%02x, scalingMode=%d\n"
1456 " current={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n"
1457 " requested={ wh={%4u,%4u} }}\n"
1458 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n"
1459 " requested={ wh={%4u,%4u} }}\n",
1460 this, getName().string(), mCurrentTransform,
1461 getEffectiveScalingMode(),
1462 c.active.w, c.active.h,
1463 c.crop.left,
1464 c.crop.top,
1465 c.crop.right,
1466 c.crop.bottom,
1467 c.crop.getWidth(),
1468 c.crop.getHeight(),
1469 c.requested.w, c.requested.h,
1470 s.active.w, s.active.h,
1471 s.crop.left,
1472 s.crop.top,
1473 s.crop.right,
1474 s.crop.bottom,
1475 s.crop.getWidth(),
1476 s.crop.getHeight(),
1477 s.requested.w, s.requested.h);
1478
1479 // record the new size, form this point on, when the client request
1480 // a buffer, it'll get the new size.
1481 mSurfaceFlingerConsumer->setDefaultBufferSize(
1482 c.requested.w, c.requested.h);
1483 }
1484
1485 const bool resizePending = (c.requested.w != c.active.w) ||
1486 (c.requested.h != c.active.h);
1487 if (!isFixedSize()) {
1488 if (resizePending && mSidebandStream == NULL) {
1489 // don't let Layer::doTransaction update the drawing state
1490 // if we have a pending resize, unless we are in fixed-size mode.
1491 // the drawing state will be updated only once we receive a buffer
1492 // with the correct size.
1493 //
1494 // in particular, we want to make sure the clip (which is part
1495 // of the geometry state) is latched together with the size but is
1496 // latched immediately when no resizing is involved.
1497 //
1498 // If a sideband stream is attached, however, we want to skip this
1499 // optimization so that transactions aren't missed when a buffer
1500 // never arrives
1501
1502 flags |= eDontUpdateGeometryState;
1503 }
1504 }
1505
1506 // always set active to requested, unless we're asked not to
1507 // this is used by Layer, which special cases resizes.
1508 if (flags & eDontUpdateGeometryState) {
1509 } else {
1510 Layer::State& editCurrentState(getCurrentState());
1511 if (mFreezePositionUpdates) {
1512 float tx = c.active.transform.tx();
1513 float ty = c.active.transform.ty();
1514 c.active = c.requested;
1515 c.active.transform.set(tx, ty);
1516 editCurrentState.active = c.active;
1517 } else {
1518 editCurrentState.active = editCurrentState.requested;
1519 c.active = c.requested;
1520 }
1521 }
1522
1523 if (s.active != c.active) {
1524 // invalidate and recompute the visible regions if needed
1525 flags |= Layer::eVisibleRegion;
1526 }
1527
1528 if (c.sequence != s.sequence) {
1529 // invalidate and recompute the visible regions if needed
1530 flags |= eVisibleRegion;
1531 this->contentDirty = true;
1532
1533 // we may use linear filtering, if the matrix scales us
1534 const uint8_t type = c.active.transform.getType();
1535 mNeedsFiltering = (!c.active.transform.preserveRects() ||
1536 (type >= Transform::SCALE));
1537 }
1538
1539 // If the layer is hidden, signal and clear out all local sync points so
1540 // that transactions for layers depending on this layer's frames becoming
1541 // visible are not blocked
1542 if (c.flags & layer_state_t::eLayerHidden) {
1543 Mutex::Autolock lock(mLocalSyncPointMutex);
1544 for (auto& point : mLocalSyncPoints) {
1545 point->setFrameAvailable();
1546 }
1547 mLocalSyncPoints.clear();
1548 }
1549
1550 // Commit the transaction
1551 commitTransaction(c);
1552 return flags;
1553 }
1554
1555 void Layer::commitTransaction(const State& stateToCommit) {
1556 mDrawingState = stateToCommit;
1557 }
1558
1559 uint32_t Layer::getTransactionFlags(uint32_t flags) {
1560 return android_atomic_and(~flags, &mTransactionFlags) & flags;
1561 }
1562
1563 uint32_t Layer::setTransactionFlags(uint32_t flags) {
1564 return android_atomic_or(flags, &mTransactionFlags);
1565 }
1566
1567 bool Layer::setPosition(float x, float y, bool immediate) {
1568 if (mCurrentState.requested.transform.tx() == x && mCurrentState.requested.transform.ty() == y)
1569 return false;
1570 mCurrentState.sequence++;
1571
1572 // We update the requested and active position simultaneously because
1573 // we want to apply the position portion of the transform matrix immediately,
1574 // but still delay scaling when resizing a SCALING_MODE_FREEZE layer.
1575 mCurrentState.requested.transform.set(x, y);
1576 if (immediate && !mFreezePositionUpdates) {
1577 mCurrentState.active.transform.set(x, y);
1578 }
1579 mFreezePositionUpdates = mFreezePositionUpdates || !immediate;
1580
1581 mCurrentState.modified = true;
1582 setTransactionFlags(eTransactionNeeded);
1583 return true;
1584 }
1585
1586 bool Layer::setLayer(uint32_t z) {
1587 if (mCurrentState.z == z)
1588 return false;
1589 mCurrentState.sequence++;
1590 mCurrentState.z = z;
1591 mCurrentState.modified = true;
1592 setTransactionFlags(eTransactionNeeded);
1593 return true;
1594 }
1595 bool Layer::setSize(uint32_t w, uint32_t h) {
1596 if (mCurrentState.requested.w == w && mCurrentState.requested.h == h)
1597 return false;
1598 mCurrentState.requested.w = w;
1599 mCurrentState.requested.h = h;
1600 mCurrentState.modified = true;
1601 setTransactionFlags(eTransactionNeeded);
1602 return true;
1603 }
1604 #ifdef USE_HWC2
1605 bool Layer::setAlpha(float alpha) {
1606 #else
1607 bool Layer::setAlpha(uint8_t alpha) {
1608 #endif
1609 if (mCurrentState.alpha == alpha)
1610 return false;
1611 mCurrentState.sequence++;
1612 mCurrentState.alpha = alpha;
1613 mCurrentState.modified = true;
1614 setTransactionFlags(eTransactionNeeded);
1615 return true;
1616 }
1617 bool Layer::setMatrix(const layer_state_t::matrix22_t& matrix) {
1618 mCurrentState.sequence++;
1619 mCurrentState.requested.transform.set(
1620 matrix.dsdx, matrix.dsdy, matrix.dtdx, matrix.dtdy);
1621 mCurrentState.modified = true;
1622 setTransactionFlags(eTransactionNeeded);
1623 return true;
1624 }
1625 bool Layer::setTransparentRegionHint(const Region& transparent) {
1626 mCurrentState.requestedTransparentRegion = transparent;
1627 mCurrentState.modified = true;
1628 setTransactionFlags(eTransactionNeeded);
1629 return true;
1630 }
1631 bool Layer::setFlags(uint8_t flags, uint8_t mask) {
1632 const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask);
1633 if (mCurrentState.flags == newFlags)
1634 return false;
1635 mCurrentState.sequence++;
1636 mCurrentState.flags = newFlags;
1637 mCurrentState.mask = mask;
1638 mCurrentState.modified = true;
1639 setTransactionFlags(eTransactionNeeded);
1640 return true;
1641 }
1642
1643 bool Layer::setCrop(const Rect& crop, bool immediate) {
1644 if (mCurrentState.crop == crop)
1645 return false;
1646 mCurrentState.sequence++;
1647 mCurrentState.requestedCrop = crop;
1648 if (immediate) {
1649 mCurrentState.crop = crop;
1650 }
1651 mCurrentState.modified = true;
1652 setTransactionFlags(eTransactionNeeded);
1653 return true;
1654 }
1655 bool Layer::setFinalCrop(const Rect& crop) {
1656 if (mCurrentState.finalCrop == crop)
1657 return false;
1658 mCurrentState.sequence++;
1659 mCurrentState.finalCrop = crop;
1660 mCurrentState.modified = true;
1661 setTransactionFlags(eTransactionNeeded);
1662 return true;
1663 }
1664
1665 bool Layer::setOverrideScalingMode(int32_t scalingMode) {
1666 if (scalingMode == mOverrideScalingMode)
1667 return false;
1668 mOverrideScalingMode = scalingMode;
1669 setTransactionFlags(eTransactionNeeded);
1670 return true;
1671 }
1672
1673 uint32_t Layer::getEffectiveScalingMode() const {
1674 if (mOverrideScalingMode >= 0) {
1675 return mOverrideScalingMode;
1676 }
1677 return mCurrentScalingMode;
1678 }
1679
1680 bool Layer::setLayerStack(uint32_t layerStack) {
1681 if (mCurrentState.layerStack == layerStack)
1682 return false;
1683 mCurrentState.sequence++;
1684 mCurrentState.layerStack = layerStack;
1685 mCurrentState.modified = true;
1686 setTransactionFlags(eTransactionNeeded);
1687 return true;
1688 }
1689
1690 void Layer::deferTransactionUntil(const sp<IBinder>& handle,
1691 uint64_t frameNumber) {
1692 mCurrentState.handle = handle;
1693 mCurrentState.frameNumber = frameNumber;
1694 // We don't set eTransactionNeeded, because just receiving a deferral
1695 // request without any other state updates shouldn't actually induce a delay
1696 mCurrentState.modified = true;
1697 pushPendingState();
1698 mCurrentState.handle = nullptr;
1699 mCurrentState.frameNumber = 0;
1700 mCurrentState.modified = false;
1701 }
1702
1703 void Layer::useSurfaceDamage() {
1704 if (mFlinger->mForceFullDamage) {
1705 surfaceDamageRegion = Region::INVALID_REGION;
1706 } else {
1707 surfaceDamageRegion = mSurfaceFlingerConsumer->getSurfaceDamage();
1708 }
1709 }
1710
1711 void Layer::useEmptyDamage() {
1712 surfaceDamageRegion.clear();
1713 }
1714
1715 // ----------------------------------------------------------------------------
1716 // pageflip handling...
1717 // ----------------------------------------------------------------------------
1718
1719 bool Layer::shouldPresentNow(const DispSync& dispSync) const {
1720 if (mSidebandStreamChanged || mAutoRefresh) {
1721 return true;
1722 }
1723
1724 Mutex::Autolock lock(mQueueItemLock);
1725 if (mQueueItems.empty()) {
1726 return false;
1727 }
1728 auto timestamp = mQueueItems[0].mTimestamp;
1729 nsecs_t expectedPresent =
1730 mSurfaceFlingerConsumer->computeExpectedPresent(dispSync);
1731
1732 // Ignore timestamps more than a second in the future
1733 bool isPlausible = timestamp < (expectedPresent + s2ns(1));
1734 ALOGW_IF(!isPlausible, "[%s] Timestamp %" PRId64 " seems implausible "
1735 "relative to expectedPresent %" PRId64, mName.string(), timestamp,
1736 expectedPresent);
1737
1738 bool isDue = timestamp < expectedPresent;
1739 return isDue || !isPlausible;
1740 }
1741
1742 bool Layer::onPreComposition() {
1743 mRefreshPending = false;
1744 return mQueuedFrames > 0 || mSidebandStreamChanged || mAutoRefresh;
1745 }
1746
1747 bool Layer::onPostComposition() {
1748 bool frameLatencyNeeded = mFrameLatencyNeeded;
1749 if (mFrameLatencyNeeded) {
1750 nsecs_t desiredPresentTime = mSurfaceFlingerConsumer->getTimestamp();
1751 mFrameTracker.setDesiredPresentTime(desiredPresentTime);
1752
1753 sp<Fence> frameReadyFence = mSurfaceFlingerConsumer->getCurrentFence();
1754 if (frameReadyFence->isValid()) {
1755 mFrameTracker.setFrameReadyFence(frameReadyFence);
1756 } else {
1757 // There was no fence for this frame, so assume that it was ready
1758 // to be presented at the desired present time.
1759 mFrameTracker.setFrameReadyTime(desiredPresentTime);
1760 }
1761
1762 const HWComposer& hwc = mFlinger->getHwComposer();
1763 #ifdef USE_HWC2
1764 sp<Fence> presentFence = hwc.getRetireFence(HWC_DISPLAY_PRIMARY);
1765 #else
1766 sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY);
1767 #endif
1768 if (presentFence->isValid()) {
1769 mFrameTracker.setActualPresentFence(presentFence);
1770 } else {
1771 // The HWC doesn't support present fences, so use the refresh
1772 // timestamp instead.
1773 nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY);
1774 mFrameTracker.setActualPresentTime(presentTime);
1775 }
1776
1777 mFrameTracker.advanceFrame();
1778 mFrameLatencyNeeded = false;
1779 }
1780 return frameLatencyNeeded;
1781 }
1782
1783 #ifdef USE_HWC2
1784 void Layer::releasePendingBuffer() {
1785 mSurfaceFlingerConsumer->releasePendingBuffer();
1786 }
1787 #endif
1788
1789 bool Layer::isVisible() const {
1790 const Layer::State& s(mDrawingState);
1791 #ifdef USE_HWC2
1792 return !(s.flags & layer_state_t::eLayerHidden) && s.alpha > 0.0f
1793 && (mActiveBuffer != NULL || mSidebandStream != NULL);
1794 #else
1795 return !(s.flags & layer_state_t::eLayerHidden) && s.alpha
1796 && (mActiveBuffer != NULL || mSidebandStream != NULL);
1797 #endif
1798 }
1799
1800 Region Layer::latchBuffer(bool& recomputeVisibleRegions)
1801 {
1802 ATRACE_CALL();
1803
1804 if (android_atomic_acquire_cas(true, false, &mSidebandStreamChanged) == 0) {
1805 // mSidebandStreamChanged was true
1806 mSidebandStream = mSurfaceFlingerConsumer->getSidebandStream();
1807 if (mSidebandStream != NULL) {
1808 setTransactionFlags(eTransactionNeeded);
1809 mFlinger->setTransactionFlags(eTraversalNeeded);
1810 }
1811 recomputeVisibleRegions = true;
1812
1813 const State& s(getDrawingState());
1814 return s.active.transform.transform(Region(Rect(s.active.w, s.active.h)));
1815 }
1816
1817 Region outDirtyRegion;
1818 if (mQueuedFrames > 0 || mAutoRefresh) {
1819
1820 // if we've already called updateTexImage() without going through
1821 // a composition step, we have to skip this layer at this point
1822 // because we cannot call updateTeximage() without a corresponding
1823 // compositionComplete() call.
1824 // we'll trigger an update in onPreComposition().
1825 if (mRefreshPending) {
1826 return outDirtyRegion;
1827 }
1828
1829 // If the head buffer's acquire fence hasn't signaled yet, return and
1830 // try again later
1831 if (!headFenceHasSignaled()) {
1832 mFlinger->signalLayerUpdate();
1833 return outDirtyRegion;
1834 }
1835
1836 // Capture the old state of the layer for comparisons later
1837 const State& s(getDrawingState());
1838 const bool oldOpacity = isOpaque(s);
1839 sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer;
1840
1841 struct Reject : public SurfaceFlingerConsumer::BufferRejecter {
1842 Layer::State& front;
1843 Layer::State& current;
1844 bool& recomputeVisibleRegions;
1845 bool stickyTransformSet;
1846 const char* name;
1847 int32_t overrideScalingMode;
1848 bool& freezePositionUpdates;
1849
1850 Reject(Layer::State& front, Layer::State& current,
1851 bool& recomputeVisibleRegions, bool stickySet,
1852 const char* name,
1853 int32_t overrideScalingMode,
1854 bool& freezePositionUpdates)
1855 : front(front), current(current),
1856 recomputeVisibleRegions(recomputeVisibleRegions),
1857 stickyTransformSet(stickySet),
1858 name(name),
1859 overrideScalingMode(overrideScalingMode),
1860 freezePositionUpdates(freezePositionUpdates) {
1861 }
1862
1863 virtual bool reject(const sp<GraphicBuffer>& buf,
1864 const BufferItem& item) {
1865 if (buf == NULL) {
1866 return false;
1867 }
1868
1869 uint32_t bufWidth = buf->getWidth();
1870 uint32_t bufHeight = buf->getHeight();
1871
1872 // check that we received a buffer of the right size
1873 // (Take the buffer's orientation into account)
1874 if (item.mTransform & Transform::ROT_90) {
1875 swap(bufWidth, bufHeight);
1876 }
1877
1878 int actualScalingMode = overrideScalingMode >= 0 ?
1879 overrideScalingMode : item.mScalingMode;
1880 bool isFixedSize = actualScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE;
1881 if (front.active != front.requested) {
1882
1883 if (isFixedSize ||
1884 (bufWidth == front.requested.w &&
1885 bufHeight == front.requested.h))
1886 {
1887 // Here we pretend the transaction happened by updating the
1888 // current and drawing states. Drawing state is only accessed
1889 // in this thread, no need to have it locked
1890 front.active = front.requested;
1891
1892 // We also need to update the current state so that
1893 // we don't end-up overwriting the drawing state with
1894 // this stale current state during the next transaction
1895 //
1896 // NOTE: We don't need to hold the transaction lock here
1897 // because State::active is only accessed from this thread.
1898 current.active = front.active;
1899 current.modified = true;
1900
1901 // recompute visible region
1902 recomputeVisibleRegions = true;
1903 }
1904
1905 ALOGD_IF(DEBUG_RESIZE,
1906 "[%s] latchBuffer/reject: buffer (%ux%u, tr=%02x), scalingMode=%d\n"
1907 " drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n"
1908 " requested={ wh={%4u,%4u} }}\n",
1909 name,
1910 bufWidth, bufHeight, item.mTransform, item.mScalingMode,
1911 front.active.w, front.active.h,
1912 front.crop.left,
1913 front.crop.top,
1914 front.crop.right,
1915 front.crop.bottom,
1916 front.crop.getWidth(),
1917 front.crop.getHeight(),
1918 front.requested.w, front.requested.h);
1919 }
1920
1921 if (!isFixedSize && !stickyTransformSet) {
1922 if (front.active.w != bufWidth ||
1923 front.active.h != bufHeight) {
1924 // reject this buffer
1925 ALOGE("[%s] rejecting buffer: "
1926 "bufWidth=%d, bufHeight=%d, front.active.{w=%d, h=%d}",
1927 name, bufWidth, bufHeight, front.active.w, front.active.h);
1928 return true;
1929 }
1930 }
1931
1932 // if the transparent region has changed (this test is
1933 // conservative, but that's fine, worst case we're doing
1934 // a bit of extra work), we latch the new one and we
1935 // trigger a visible-region recompute.
1936 if (!front.activeTransparentRegion.isTriviallyEqual(
1937 front.requestedTransparentRegion)) {
1938 front.activeTransparentRegion = front.requestedTransparentRegion;
1939
1940 // We also need to update the current state so that
1941 // we don't end-up overwriting the drawing state with
1942 // this stale current state during the next transaction
1943 //
1944 // NOTE: We don't need to hold the transaction lock here
1945 // because State::active is only accessed from this thread.
1946 current.activeTransparentRegion = front.activeTransparentRegion;
1947
1948 // recompute visible region
1949 recomputeVisibleRegions = true;
1950 }
1951
1952 if (front.crop != front.requestedCrop) {
1953 front.crop = front.requestedCrop;
1954 current.crop = front.requestedCrop;
1955 recomputeVisibleRegions = true;
1956 }
1957 freezePositionUpdates = false;
1958
1959 return false;
1960 }
1961 };
1962
1963 Reject r(mDrawingState, getCurrentState(), recomputeVisibleRegions,
1964 getProducerStickyTransform() != 0, mName.string(),
1965 mOverrideScalingMode, mFreezePositionUpdates);
1966
1967
1968 // Check all of our local sync points to ensure that all transactions
1969 // which need to have been applied prior to the frame which is about to
1970 // be latched have signaled
1971
1972 auto headFrameNumber = getHeadFrameNumber();
1973 bool matchingFramesFound = false;
1974 bool allTransactionsApplied = true;
1975 {
1976 Mutex::Autolock lock(mLocalSyncPointMutex);
1977 for (auto& point : mLocalSyncPoints) {
1978 if (point->getFrameNumber() > headFrameNumber) {
1979 break;
1980 }
1981
1982 matchingFramesFound = true;
1983
1984 if (!point->frameIsAvailable()) {
1985 // We haven't notified the remote layer that the frame for
1986 // this point is available yet. Notify it now, and then
1987 // abort this attempt to latch.
1988 point->setFrameAvailable();
1989 allTransactionsApplied = false;
1990 break;
1991 }
1992
1993 allTransactionsApplied &= point->transactionIsApplied();
1994 }
1995 }
1996
1997 if (matchingFramesFound && !allTransactionsApplied) {
1998 mFlinger->signalLayerUpdate();
1999 return outDirtyRegion;
2000 }
2001
2002 // This boolean is used to make sure that SurfaceFlinger's shadow copy
2003 // of the buffer queue isn't modified when the buffer queue is returning
2004 // BufferItem's that weren't actually queued. This can happen in shared
2005 // buffer mode.
2006 bool queuedBuffer = false;
2007 status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r,
2008 mFlinger->mPrimaryDispSync, &mAutoRefresh, &queuedBuffer,
2009 mLastFrameNumberReceived);
2010 if (updateResult == BufferQueue::PRESENT_LATER) {
2011 // Producer doesn't want buffer to be displayed yet. Signal a
2012 // layer update so we check again at the next opportunity.
2013 mFlinger->signalLayerUpdate();
2014 return outDirtyRegion;
2015 } else if (updateResult == SurfaceFlingerConsumer::BUFFER_REJECTED) {
2016 // If the buffer has been rejected, remove it from the shadow queue
2017 // and return early
2018 if (queuedBuffer) {
2019 Mutex::Autolock lock(mQueueItemLock);
2020 mQueueItems.removeAt(0);
2021 android_atomic_dec(&mQueuedFrames);
2022 }
2023 return outDirtyRegion;
2024 } else if (updateResult != NO_ERROR || mUpdateTexImageFailed) {
2025 // This can occur if something goes wrong when trying to create the
2026 // EGLImage for this buffer. If this happens, the buffer has already
2027 // been released, so we need to clean up the queue and bug out
2028 // early.
2029 if (queuedBuffer) {
2030 Mutex::Autolock lock(mQueueItemLock);
2031 mQueueItems.clear();
2032 android_atomic_and(0, &mQueuedFrames);
2033 }
2034
2035 // Once we have hit this state, the shadow queue may no longer
2036 // correctly reflect the incoming BufferQueue's contents, so even if
2037 // updateTexImage starts working, the only safe course of action is
2038 // to continue to ignore updates.
2039 mUpdateTexImageFailed = true;
2040
2041 return outDirtyRegion;
2042 }
2043
2044 if (queuedBuffer) {
2045 // Autolock scope
2046 auto currentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber();
2047
2048 Mutex::Autolock lock(mQueueItemLock);
2049
2050 // Remove any stale buffers that have been dropped during
2051 // updateTexImage
2052 while (mQueueItems[0].mFrameNumber != currentFrameNumber) {
2053 mQueueItems.removeAt(0);
2054 android_atomic_dec(&mQueuedFrames);
2055 }
2056
2057 mQueueItems.removeAt(0);
2058 }
2059
2060
2061 // Decrement the queued-frames count. Signal another event if we
2062 // have more frames pending.
2063 if ((queuedBuffer && android_atomic_dec(&mQueuedFrames) > 1)
2064 || mAutoRefresh) {
2065 mFlinger->signalLayerUpdate();
2066 }
2067
2068 if (updateResult != NO_ERROR) {
2069 // something happened!
2070 recomputeVisibleRegions = true;
2071 return outDirtyRegion;
2072 }
2073
2074 // update the active buffer
2075 mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer();
2076 if (mActiveBuffer == NULL) {
2077 // this can only happen if the very first buffer was rejected.
2078 return outDirtyRegion;
2079 }
2080
2081 mRefreshPending = true;
2082 mFrameLatencyNeeded = true;
2083 if (oldActiveBuffer == NULL) {
2084 // the first time we receive a buffer, we need to trigger a
2085 // geometry invalidation.
2086 recomputeVisibleRegions = true;
2087 }
2088
2089 Rect crop(mSurfaceFlingerConsumer->getCurrentCrop());
2090 const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform());
2091 const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode());
2092 if ((crop != mCurrentCrop) ||
2093 (transform != mCurrentTransform) ||
2094 (scalingMode != mCurrentScalingMode))
2095 {
2096 mCurrentCrop = crop;
2097 mCurrentTransform = transform;
2098 mCurrentScalingMode = scalingMode;
2099 recomputeVisibleRegions = true;
2100 }
2101
2102 if (oldActiveBuffer != NULL) {
2103 uint32_t bufWidth = mActiveBuffer->getWidth();
2104 uint32_t bufHeight = mActiveBuffer->getHeight();
2105 if (bufWidth != uint32_t(oldActiveBuffer->width) ||
2106 bufHeight != uint32_t(oldActiveBuffer->height)) {
2107 recomputeVisibleRegions = true;
2108 }
2109 }
2110
2111 mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format);
2112 if (oldOpacity != isOpaque(s)) {
2113 recomputeVisibleRegions = true;
2114 }
2115
2116 mCurrentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber();
2117
2118 // Remove any sync points corresponding to the buffer which was just
2119 // latched
2120 {
2121 Mutex::Autolock lock(mLocalSyncPointMutex);
2122 auto point = mLocalSyncPoints.begin();
2123 while (point != mLocalSyncPoints.end()) {
2124 if (!(*point)->frameIsAvailable() ||
2125 !(*point)->transactionIsApplied()) {
2126 // This sync point must have been added since we started
2127 // latching. Don't drop it yet.
2128 ++point;
2129 continue;
2130 }
2131
2132 if ((*point)->getFrameNumber() <= mCurrentFrameNumber) {
2133 point = mLocalSyncPoints.erase(point);
2134 } else {
2135 ++point;
2136 }
2137 }
2138 }
2139
2140 // FIXME: postedRegion should be dirty & bounds
2141 Region dirtyRegion(Rect(s.active.w, s.active.h));
2142
2143 // transform the dirty region to window-manager space
2144 outDirtyRegion = (s.active.transform.transform(dirtyRegion));
2145 }
2146 return outDirtyRegion;
2147 }
2148
2149 uint32_t Layer::getEffectiveUsage(uint32_t usage) const
2150 {
2151 // TODO: should we do something special if mSecure is set?
2152 if (mProtectedByApp) {
2153 // need a hardware-protected path to external video sink
2154 usage |= GraphicBuffer::USAGE_PROTECTED;
2155 }
2156 if (mPotentialCursor) {
2157 usage |= GraphicBuffer::USAGE_CURSOR;
2158 }
2159 usage |= GraphicBuffer::USAGE_HW_COMPOSER;
2160 return usage;
2161 }
2162
2163 void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const {
2164 uint32_t orientation = 0;
2165 if (!mFlinger->mDebugDisableTransformHint) {
2166 // The transform hint is used to improve performance, but we can
2167 // only have a single transform hint, it cannot
2168 // apply to all displays.
2169 const Transform& planeTransform(hw->getTransform());
2170 orientation = planeTransform.getOrientation();
2171 if (orientation & Transform::ROT_INVALID) {
2172 orientation = 0;
2173 }
2174 }
2175 mSurfaceFlingerConsumer->setTransformHint(orientation);
2176 }
2177
2178 // ----------------------------------------------------------------------------
2179 // debugging
2180 // ----------------------------------------------------------------------------
2181
2182 void Layer::dump(String8& result, Colorizer& colorizer) const
2183 {
2184 const Layer::State& s(getDrawingState());
2185
2186 colorizer.colorize(result, Colorizer::GREEN);
2187 result.appendFormat(
2188 "+ %s %p (%s)\n",
2189 getTypeId(), this, getName().string());
2190 colorizer.reset(result);
2191
2192 s.activeTransparentRegion.dump(result, "transparentRegion");
2193 visibleRegion.dump(result, "visibleRegion");
2194 surfaceDamageRegion.dump(result, "surfaceDamageRegion");
2195 sp<Client> client(mClientRef.promote());
2196
2197 result.appendFormat( " "
2198 "layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), "
2199 "crop=(%4d,%4d,%4d,%4d), finalCrop=(%4d,%4d,%4d,%4d), "
2200 "isOpaque=%1d, invalidate=%1d, "
2201 #ifdef USE_HWC2
2202 "alpha=%.3f, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n"
2203 #else
2204 "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n"
2205 #endif
2206 " client=%p\n",
2207 s.layerStack, s.z, s.active.transform.tx(), s.active.transform.ty(), s.active.w, s.active.h,
2208 s.crop.left, s.crop.top,
2209 s.crop.right, s.crop.bottom,
2210 s.finalCrop.left, s.finalCrop.top,
2211 s.finalCrop.right, s.finalCrop.bottom,
2212 isOpaque(s), contentDirty,
2213 s.alpha, s.flags,
2214 s.active.transform[0][0], s.active.transform[0][1],
2215 s.active.transform[1][0], s.active.transform[1][1],
2216 client.get());
2217
2218 sp<const GraphicBuffer> buf0(mActiveBuffer);
2219 uint32_t w0=0, h0=0, s0=0, f0=0;
2220 if (buf0 != 0) {
2221 w0 = buf0->getWidth();
2222 h0 = buf0->getHeight();
2223 s0 = buf0->getStride();
2224 f0 = buf0->format;
2225 }
2226 result.appendFormat(
2227 " "
2228 "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X],"
2229 " queued-frames=%d, mRefreshPending=%d\n",
2230 mFormat, w0, h0, s0,f0,
2231 mQueuedFrames, mRefreshPending);
2232
2233 if (mSurfaceFlingerConsumer != 0) {
2234 mSurfaceFlingerConsumer->dump(result, " ");
2235 }
2236 }
2237
2238 void Layer::dumpFrameStats(String8& result) const {
2239 mFrameTracker.dumpStats(result);
2240 }
2241
2242 void Layer::clearFrameStats() {
2243 mFrameTracker.clearStats();
2244 }
2245
2246 void Layer::logFrameStats() {
2247 mFrameTracker.logAndResetStats(mName);
2248 }
2249
2250 void Layer::getFrameStats(FrameStats* outStats) const {
2251 mFrameTracker.getStats(outStats);
2252 }
2253
2254 void Layer::getFenceData(String8* outName, uint64_t* outFrameNumber,
2255 bool* outIsGlesComposition, nsecs_t* outPostedTime,
2256 sp<Fence>* outAcquireFence, sp<Fence>* outPrevReleaseFence) const {
2257 *outName = mName;
2258 *outFrameNumber = mSurfaceFlingerConsumer->getFrameNumber();
2259
2260 #ifdef USE_HWC2
2261 *outIsGlesComposition = mHwcLayers.count(HWC_DISPLAY_PRIMARY) ?
2262 mHwcLayers.at(HWC_DISPLAY_PRIMARY).compositionType ==
2263 HWC2::Composition::Client : true;
2264 #else
2265 *outIsGlesComposition = mIsGlesComposition;
2266 #endif
2267 *outPostedTime = mSurfaceFlingerConsumer->getTimestamp();
2268 *outAcquireFence = mSurfaceFlingerConsumer->getCurrentFence();
2269 *outPrevReleaseFence = mSurfaceFlingerConsumer->getPrevReleaseFence();
2270 }
2271
2272 std::vector<OccupancyTracker::Segment> Layer::getOccupancyHistory(
2273 bool forceFlush) {
2274 std::vector<OccupancyTracker::Segment> history;
2275 status_t result = mSurfaceFlingerConsumer->getOccupancyHistory(forceFlush,
2276 &history);
2277 if (result != NO_ERROR) {
2278 ALOGW("[%s] Failed to obtain occupancy history (%d)", mName.string(),
2279 result);
2280 return {};
2281 }
2282 return history;
2283 }
2284
2285 bool Layer::getTransformToDisplayInverse() const {
2286 return mSurfaceFlingerConsumer->getTransformToDisplayInverse();
2287 }
2288
2289 // ---------------------------------------------------------------------------
2290
2291 Layer::LayerCleaner::LayerCleaner(const sp<SurfaceFlinger>& flinger,
2292 const sp<Layer>& layer)
2293 : mFlinger(flinger), mLayer(layer) {
2294 }
2295
2296 Layer::LayerCleaner::~LayerCleaner() {
2297 // destroy client resources
2298 mFlinger->onLayerDestroyed(mLayer);
2299 }
2300
2301 // ---------------------------------------------------------------------------
2302 }; // namespace android
2303
2304 #if defined(__gl_h_)
2305 #error "don't include gl/gl.h in this file"
2306 #endif
2307
2308 #if defined(__gl2_h_)
2309 #error "don't include gl2/gl2.h in this file"
2310 #endif
2311