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