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