Layer.cpp revision 51450039e2fd266b31f33dfd1b4353bc1b0b145a 
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, true);
563        // This needs to be here as transform.transform(Rect) computes the
564        // transformed rect and then takes the bounding box of the result before
565        // returning. This means
566        // transform.inverse().transform(transform.transform(Rect)) != Rect
567        // in which case we need to make sure the final rect is clipped to the
568        // display bounds.
569        if(!activeCrop.intersect(Rect(s.active.w, s.active.h), &activeCrop)) {
570            activeCrop.clear();
571        }
572        // mark regions outside the crop as transparent
573        activeTransparentRegion.orSelf(Rect(0, 0, s.active.w, activeCrop.top));
574        activeTransparentRegion.orSelf(Rect(0, activeCrop.bottom,
575                s.active.w, s.active.h));
576        activeTransparentRegion.orSelf(Rect(0, activeCrop.top,
577                activeCrop.left, activeCrop.bottom));
578        activeTransparentRegion.orSelf(Rect(activeCrop.right, activeCrop.top,
579                s.active.w, activeCrop.bottom));
580    }
581    Rect frame(s.active.transform.transform(computeBounds(activeTransparentRegion)));
582    if (!s.finalCrop.isEmpty()) {
583        if(!frame.intersect(s.finalCrop, &frame)) {
584            frame.clear();
585        }
586    }
587#ifdef USE_HWC2
588    if (!frame.intersect(displayDevice->getViewport(), &frame)) {
589        frame.clear();
590    }
591    const Transform& tr(displayDevice->getTransform());
592    Rect transformedFrame = tr.transform(frame);
593    auto error = hwcLayer->setDisplayFrame(transformedFrame);
594    ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set display frame "
595            "[%d, %d, %d, %d]: %s (%d)", mName.string(), transformedFrame.left,
596            transformedFrame.top, transformedFrame.right,
597            transformedFrame.bottom, to_string(error).c_str(),
598            static_cast<int32_t>(error));
599
600    FloatRect sourceCrop = computeCrop(displayDevice);
601    error = hwcLayer->setSourceCrop(sourceCrop);
602    ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set source crop "
603            "[%.3f, %.3f, %.3f, %.3f]: %s (%d)", mName.string(),
604            sourceCrop.left, sourceCrop.top, sourceCrop.right,
605            sourceCrop.bottom, to_string(error).c_str(),
606            static_cast<int32_t>(error));
607
608    error = hwcLayer->setPlaneAlpha(s.alpha);
609    ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set plane alpha %.3f: "
610            "%s (%d)", mName.string(), s.alpha, to_string(error).c_str(),
611            static_cast<int32_t>(error));
612
613    error = hwcLayer->setZOrder(s.z);
614    ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set Z %u: %s (%d)",
615            mName.string(), s.z, to_string(error).c_str(),
616            static_cast<int32_t>(error));
617#else
618    if (!frame.intersect(hw->getViewport(), &frame)) {
619        frame.clear();
620    }
621    const Transform& tr(hw->getTransform());
622    layer.setFrame(tr.transform(frame));
623    layer.setCrop(computeCrop(hw));
624    layer.setPlaneAlpha(s.alpha);
625#endif
626
627    /*
628     * Transformations are applied in this order:
629     * 1) buffer orientation/flip/mirror
630     * 2) state transformation (window manager)
631     * 3) layer orientation (screen orientation)
632     * (NOTE: the matrices are multiplied in reverse order)
633     */
634
635    const Transform bufferOrientation(mCurrentTransform);
636    Transform transform(tr * s.active.transform * bufferOrientation);
637
638    if (mSurfaceFlingerConsumer->getTransformToDisplayInverse()) {
639        /*
640         * the code below applies the primary display's inverse transform to the
641         * buffer
642         */
643        uint32_t invTransform =
644                DisplayDevice::getPrimaryDisplayOrientationTransform();
645        // calculate the inverse transform
646        if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) {
647            invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V |
648                    NATIVE_WINDOW_TRANSFORM_FLIP_H;
649        }
650        // and apply to the current transform
651        transform = Transform(invTransform) * transform;
652    }
653
654    // this gives us only the "orientation" component of the transform
655    const uint32_t orientation = transform.getOrientation();
656#ifdef USE_HWC2
657    if (orientation & Transform::ROT_INVALID) {
658        // we can only handle simple transformation
659        hwcInfo.forceClientComposition = true;
660    } else {
661        auto transform = static_cast<HWC2::Transform>(orientation);
662        auto error = hwcLayer->setTransform(transform);
663        ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set transform %s: "
664                "%s (%d)", mName.string(), to_string(transform).c_str(),
665                to_string(error).c_str(), static_cast<int32_t>(error));
666    }
667#else
668    if (orientation & Transform::ROT_INVALID) {
669        // we can only handle simple transformation
670        layer.setSkip(true);
671    } else {
672        layer.setTransform(orientation);
673    }
674#endif
675}
676
677#ifdef USE_HWC2
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
736        // For now, we only support black for DimLayer
737        error = hwcLayer->setColor({0, 0, 0, 255});
738        if (error != HWC2::Error::None) {
739            ALOGE("[%s] Failed to set color: %s (%d)", mName.string(),
740                    to_string(error).c_str(), static_cast<int32_t>(error));
741        }
742
743        // Clear out the transform, because it doesn't make sense absent a
744        // source buffer
745        error = hwcLayer->setTransform(HWC2::Transform::None);
746        if (error != HWC2::Error::None) {
747            ALOGE("[%s] Failed to clear transform: %s (%d)", mName.string(),
748                    to_string(error).c_str(), static_cast<int32_t>(error));
749        }
750
751        return;
752    }
753
754    // Device or Cursor layers
755    if (mPotentialCursor) {
756        ALOGV("[%s] Requesting Cursor composition", mName.string());
757        setCompositionType(hwcId, HWC2::Composition::Cursor);
758    } else {
759        ALOGV("[%s] Requesting Device composition", mName.string());
760        setCompositionType(hwcId, HWC2::Composition::Device);
761    }
762
763    auto acquireFence = mSurfaceFlingerConsumer->getCurrentFence();
764    error = hwcLayer->setBuffer(mActiveBuffer->handle, acquireFence);
765    if (error != HWC2::Error::None) {
766        ALOGE("[%s] Failed to set buffer %p: %s (%d)", mName.string(),
767                mActiveBuffer->handle, to_string(error).c_str(),
768                static_cast<int32_t>(error));
769    }
770}
771#else
772void Layer::setPerFrameData(const sp<const DisplayDevice>& hw,
773        HWComposer::HWCLayerInterface& layer) {
774    // we have to set the visible region on every frame because
775    // we currently free it during onLayerDisplayed(), which is called
776    // after HWComposer::commit() -- every frame.
777    // Apply this display's projection's viewport to the visible region
778    // before giving it to the HWC HAL.
779    const Transform& tr = hw->getTransform();
780    Region visible = tr.transform(visibleRegion.intersect(hw->getViewport()));
781    layer.setVisibleRegionScreen(visible);
782    layer.setSurfaceDamage(surfaceDamageRegion);
783    mIsGlesComposition = (layer.getCompositionType() == HWC_FRAMEBUFFER);
784
785    if (mSidebandStream.get()) {
786        layer.setSidebandStream(mSidebandStream);
787    } else {
788        // NOTE: buffer can be NULL if the client never drew into this
789        // layer yet, or if we ran out of memory
790        layer.setBuffer(mActiveBuffer);
791    }
792}
793#endif
794
795#ifdef USE_HWC2
796void Layer::updateCursorPosition(const sp<const DisplayDevice>& displayDevice) {
797    auto hwcId = displayDevice->getHwcDisplayId();
798    if (mHwcLayers.count(hwcId) == 0 ||
799            getCompositionType(hwcId) != HWC2::Composition::Cursor) {
800        return;
801    }
802
803    // This gives us only the "orientation" component of the transform
804    const State& s(getCurrentState());
805
806    // Apply the layer's transform, followed by the display's global transform
807    // Here we're guaranteed that the layer's transform preserves rects
808    Rect win(s.active.w, s.active.h);
809    if (!s.crop.isEmpty()) {
810        win.intersect(s.crop, &win);
811    }
812    // Subtract the transparent region and snap to the bounds
813    Rect bounds = reduce(win, s.activeTransparentRegion);
814    Rect frame(s.active.transform.transform(bounds));
815    frame.intersect(displayDevice->getViewport(), &frame);
816    if (!s.finalCrop.isEmpty()) {
817        frame.intersect(s.finalCrop, &frame);
818    }
819    auto& displayTransform(displayDevice->getTransform());
820    auto position = displayTransform.transform(frame);
821
822    auto error = mHwcLayers[hwcId].layer->setCursorPosition(position.left,
823            position.top);
824    ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set cursor position "
825            "to (%d, %d): %s (%d)", mName.string(), position.left,
826            position.top, to_string(error).c_str(),
827            static_cast<int32_t>(error));
828}
829#else
830void Layer::setAcquireFence(const sp<const DisplayDevice>& /* hw */,
831        HWComposer::HWCLayerInterface& layer) {
832    int fenceFd = -1;
833
834    // TODO: there is a possible optimization here: we only need to set the
835    // acquire fence the first time a new buffer is acquired on EACH display.
836
837    if (layer.getCompositionType() == HWC_OVERLAY || layer.getCompositionType() == HWC_CURSOR_OVERLAY) {
838        sp<Fence> fence = mSurfaceFlingerConsumer->getCurrentFence();
839        if (fence->isValid()) {
840            fenceFd = fence->dup();
841            if (fenceFd == -1) {
842                ALOGW("failed to dup layer fence, skipping sync: %d", errno);
843            }
844        }
845    }
846    layer.setAcquireFenceFd(fenceFd);
847}
848
849Rect Layer::getPosition(
850    const sp<const DisplayDevice>& hw)
851{
852    // this gives us only the "orientation" component of the transform
853    const State& s(getCurrentState());
854
855    // apply the layer's transform, followed by the display's global transform
856    // here we're guaranteed that the layer's transform preserves rects
857    Rect win(s.active.w, s.active.h);
858    if (!s.crop.isEmpty()) {
859        win.intersect(s.crop, &win);
860    }
861    // subtract the transparent region and snap to the bounds
862    Rect bounds = reduce(win, s.activeTransparentRegion);
863    Rect frame(s.active.transform.transform(bounds));
864    frame.intersect(hw->getViewport(), &frame);
865    if (!s.finalCrop.isEmpty()) {
866        frame.intersect(s.finalCrop, &frame);
867    }
868    const Transform& tr(hw->getTransform());
869    return Rect(tr.transform(frame));
870}
871#endif
872
873// ---------------------------------------------------------------------------
874// drawing...
875// ---------------------------------------------------------------------------
876
877void Layer::draw(const sp<const DisplayDevice>& hw, const Region& clip) const {
878    onDraw(hw, clip, false);
879}
880
881void Layer::draw(const sp<const DisplayDevice>& hw,
882        bool useIdentityTransform) const {
883    onDraw(hw, Region(hw->bounds()), useIdentityTransform);
884}
885
886void Layer::draw(const sp<const DisplayDevice>& hw) const {
887    onDraw(hw, Region(hw->bounds()), false);
888}
889
890void Layer::onDraw(const sp<const DisplayDevice>& hw, const Region& clip,
891        bool useIdentityTransform) const
892{
893    ATRACE_CALL();
894
895    if (CC_UNLIKELY(mActiveBuffer == 0)) {
896        // the texture has not been created yet, this Layer has
897        // in fact never been drawn into. This happens frequently with
898        // SurfaceView because the WindowManager can't know when the client
899        // has drawn the first time.
900
901        // If there is nothing under us, we paint the screen in black, otherwise
902        // we just skip this update.
903
904        // figure out if there is something below us
905        Region under;
906        const SurfaceFlinger::LayerVector& drawingLayers(
907                mFlinger->mDrawingState.layersSortedByZ);
908        const size_t count = drawingLayers.size();
909        for (size_t i=0 ; i<count ; ++i) {
910            const sp<Layer>& layer(drawingLayers[i]);
911            if (layer.get() == static_cast<Layer const*>(this))
912                break;
913            under.orSelf( hw->getTransform().transform(layer->visibleRegion) );
914        }
915        // if not everything below us is covered, we plug the holes!
916        Region holes(clip.subtract(under));
917        if (!holes.isEmpty()) {
918            clearWithOpenGL(hw, holes, 0, 0, 0, 1);
919        }
920        return;
921    }
922
923    // Bind the current buffer to the GL texture, and wait for it to be
924    // ready for us to draw into.
925    status_t err = mSurfaceFlingerConsumer->bindTextureImage();
926    if (err != NO_ERROR) {
927        ALOGW("onDraw: bindTextureImage failed (err=%d)", err);
928        // Go ahead and draw the buffer anyway; no matter what we do the screen
929        // is probably going to have something visibly wrong.
930    }
931
932    bool blackOutLayer = isProtected() || (isSecure() && !hw->isSecure());
933
934    RenderEngine& engine(mFlinger->getRenderEngine());
935
936    if (!blackOutLayer) {
937        // TODO: we could be more subtle with isFixedSize()
938        const bool useFiltering = getFiltering() || needsFiltering(hw) || isFixedSize();
939
940        // Query the texture matrix given our current filtering mode.
941        float textureMatrix[16];
942        mSurfaceFlingerConsumer->setFilteringEnabled(useFiltering);
943        mSurfaceFlingerConsumer->getTransformMatrix(textureMatrix);
944
945        if (mSurfaceFlingerConsumer->getTransformToDisplayInverse()) {
946
947            /*
948             * the code below applies the primary display's inverse transform to
949             * the texture transform
950             */
951
952            // create a 4x4 transform matrix from the display transform flags
953            const mat4 flipH(-1,0,0,0,  0,1,0,0, 0,0,1,0, 1,0,0,1);
954            const mat4 flipV( 1,0,0,0, 0,-1,0,0, 0,0,1,0, 0,1,0,1);
955            const mat4 rot90( 0,1,0,0, -1,0,0,0, 0,0,1,0, 1,0,0,1);
956
957            mat4 tr;
958            uint32_t transform =
959                    DisplayDevice::getPrimaryDisplayOrientationTransform();
960            if (transform & NATIVE_WINDOW_TRANSFORM_ROT_90)
961                tr = tr * rot90;
962            if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_H)
963                tr = tr * flipH;
964            if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_V)
965                tr = tr * flipV;
966
967            // calculate the inverse
968            tr = inverse(tr);
969
970            // and finally apply it to the original texture matrix
971            const mat4 texTransform(mat4(static_cast<const float*>(textureMatrix)) * tr);
972            memcpy(textureMatrix, texTransform.asArray(), sizeof(textureMatrix));
973        }
974
975        // Set things up for texturing.
976        mTexture.setDimensions(mActiveBuffer->getWidth(), mActiveBuffer->getHeight());
977        mTexture.setFiltering(useFiltering);
978        mTexture.setMatrix(textureMatrix);
979
980        engine.setupLayerTexturing(mTexture);
981    } else {
982        engine.setupLayerBlackedOut();
983    }
984    drawWithOpenGL(hw, clip, useIdentityTransform);
985    engine.disableTexturing();
986}
987
988
989void Layer::clearWithOpenGL(const sp<const DisplayDevice>& hw,
990        const Region& /* clip */, float red, float green, float blue,
991        float alpha) const
992{
993    RenderEngine& engine(mFlinger->getRenderEngine());
994    computeGeometry(hw, mMesh, false);
995    engine.setupFillWithColor(red, green, blue, alpha);
996    engine.drawMesh(mMesh);
997}
998
999void Layer::clearWithOpenGL(
1000        const sp<const DisplayDevice>& hw, const Region& clip) const {
1001    clearWithOpenGL(hw, clip, 0,0,0,0);
1002}
1003
1004void Layer::drawWithOpenGL(const sp<const DisplayDevice>& hw,
1005        const Region& /* clip */, bool useIdentityTransform) const {
1006    const State& s(getDrawingState());
1007
1008    computeGeometry(hw, mMesh, useIdentityTransform);
1009
1010    /*
1011     * NOTE: the way we compute the texture coordinates here produces
1012     * different results than when we take the HWC path -- in the later case
1013     * the "source crop" is rounded to texel boundaries.
1014     * This can produce significantly different results when the texture
1015     * is scaled by a large amount.
1016     *
1017     * The GL code below is more logical (imho), and the difference with
1018     * HWC is due to a limitation of the HWC API to integers -- a question
1019     * is suspend is whether we should ignore this problem or revert to
1020     * GL composition when a buffer scaling is applied (maybe with some
1021     * minimal value)? Or, we could make GL behave like HWC -- but this feel
1022     * like more of a hack.
1023     */
1024    Rect win(computeBounds());
1025
1026    if (!s.finalCrop.isEmpty()) {
1027        win = s.active.transform.transform(win);
1028        if (!win.intersect(s.finalCrop, &win)) {
1029            win.clear();
1030        }
1031        win = s.active.transform.inverse().transform(win);
1032        if (!win.intersect(computeBounds(), &win)) {
1033            win.clear();
1034        }
1035    }
1036
1037    float left   = float(win.left)   / float(s.active.w);
1038    float top    = float(win.top)    / float(s.active.h);
1039    float right  = float(win.right)  / float(s.active.w);
1040    float bottom = float(win.bottom) / float(s.active.h);
1041
1042    // TODO: we probably want to generate the texture coords with the mesh
1043    // here we assume that we only have 4 vertices
1044    Mesh::VertexArray<vec2> texCoords(mMesh.getTexCoordArray<vec2>());
1045    texCoords[0] = vec2(left, 1.0f - top);
1046    texCoords[1] = vec2(left, 1.0f - bottom);
1047    texCoords[2] = vec2(right, 1.0f - bottom);
1048    texCoords[3] = vec2(right, 1.0f - top);
1049
1050    RenderEngine& engine(mFlinger->getRenderEngine());
1051    engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(s), s.alpha);
1052    engine.drawMesh(mMesh);
1053    engine.disableBlending();
1054}
1055
1056#ifdef USE_HWC2
1057void Layer::setCompositionType(int32_t hwcId, HWC2::Composition type,
1058        bool callIntoHwc) {
1059    if (mHwcLayers.count(hwcId) == 0) {
1060        ALOGE("setCompositionType called without a valid HWC layer");
1061        return;
1062    }
1063    auto& hwcInfo = mHwcLayers[hwcId];
1064    auto& hwcLayer = hwcInfo.layer;
1065    ALOGV("setCompositionType(%" PRIx64 ", %s, %d)", hwcLayer->getId(),
1066            to_string(type).c_str(), static_cast<int>(callIntoHwc));
1067    if (hwcInfo.compositionType != type) {
1068        ALOGV("    actually setting");
1069        hwcInfo.compositionType = type;
1070        if (callIntoHwc) {
1071            auto error = hwcLayer->setCompositionType(type);
1072            ALOGE_IF(error != HWC2::Error::None, "[%s] Failed to set "
1073                    "composition type %s: %s (%d)", mName.string(),
1074                    to_string(type).c_str(), to_string(error).c_str(),
1075                    static_cast<int32_t>(error));
1076        }
1077    }
1078}
1079
1080HWC2::Composition Layer::getCompositionType(int32_t hwcId) const {
1081    if (hwcId == DisplayDevice::DISPLAY_ID_INVALID) {
1082        // If we're querying the composition type for a display that does not
1083        // have a HWC counterpart, then it will always be Client
1084        return HWC2::Composition::Client;
1085    }
1086    if (mHwcLayers.count(hwcId) == 0) {
1087        ALOGE("getCompositionType called with an invalid HWC layer");
1088        return HWC2::Composition::Invalid;
1089    }
1090    return mHwcLayers.at(hwcId).compositionType;
1091}
1092
1093void Layer::setClearClientTarget(int32_t hwcId, bool clear) {
1094    if (mHwcLayers.count(hwcId) == 0) {
1095        ALOGE("setClearClientTarget called without a valid HWC layer");
1096        return;
1097    }
1098    mHwcLayers[hwcId].clearClientTarget = clear;
1099}
1100
1101bool Layer::getClearClientTarget(int32_t hwcId) const {
1102    if (mHwcLayers.count(hwcId) == 0) {
1103        ALOGE("getClearClientTarget called without a valid HWC layer");
1104        return false;
1105    }
1106    return mHwcLayers.at(hwcId).clearClientTarget;
1107}
1108#endif
1109
1110uint32_t Layer::getProducerStickyTransform() const {
1111    int producerStickyTransform = 0;
1112    int ret = mProducer->query(NATIVE_WINDOW_STICKY_TRANSFORM, &producerStickyTransform);
1113    if (ret != OK) {
1114        ALOGW("%s: Error %s (%d) while querying window sticky transform.", __FUNCTION__,
1115                strerror(-ret), ret);
1116        return 0;
1117    }
1118    return static_cast<uint32_t>(producerStickyTransform);
1119}
1120
1121bool Layer::latchUnsignaledBuffers() {
1122    static bool propertyLoaded = false;
1123    static bool latch = false;
1124    static std::mutex mutex;
1125    std::lock_guard<std::mutex> lock(mutex);
1126    if (!propertyLoaded) {
1127        char value[PROPERTY_VALUE_MAX] = {};
1128        property_get("debug.sf.latch_unsignaled", value, "0");
1129        latch = atoi(value);
1130        propertyLoaded = true;
1131    }
1132    return latch;
1133}
1134
1135uint64_t Layer::getHeadFrameNumber() const {
1136    Mutex::Autolock lock(mQueueItemLock);
1137    if (!mQueueItems.empty()) {
1138        return mQueueItems[0].mFrameNumber;
1139    } else {
1140        return mCurrentFrameNumber;
1141    }
1142}
1143
1144bool Layer::headFenceHasSignaled() const {
1145#ifdef USE_HWC2
1146    if (latchUnsignaledBuffers()) {
1147        return true;
1148    }
1149
1150    Mutex::Autolock lock(mQueueItemLock);
1151    if (mQueueItems.empty()) {
1152        return true;
1153    }
1154    if (mQueueItems[0].mIsDroppable) {
1155        // Even though this buffer's fence may not have signaled yet, it could
1156        // be replaced by another buffer before it has a chance to, which means
1157        // that it's possible to get into a situation where a buffer is never
1158        // able to be latched. To avoid this, grab this buffer anyway.
1159        return true;
1160    }
1161    return mQueueItems[0].mFence->getSignalTime() != INT64_MAX;
1162#else
1163    return true;
1164#endif
1165}
1166
1167bool Layer::addSyncPoint(const std::shared_ptr<SyncPoint>& point) {
1168    if (point->getFrameNumber() <= mCurrentFrameNumber) {
1169        // Don't bother with a SyncPoint, since we've already latched the
1170        // relevant frame
1171        return false;
1172    }
1173
1174    Mutex::Autolock lock(mLocalSyncPointMutex);
1175    mLocalSyncPoints.push_back(point);
1176    return true;
1177}
1178
1179void Layer::setFiltering(bool filtering) {
1180    mFiltering = filtering;
1181}
1182
1183bool Layer::getFiltering() const {
1184    return mFiltering;
1185}
1186
1187// As documented in libhardware header, formats in the range
1188// 0x100 - 0x1FF are specific to the HAL implementation, and
1189// are known to have no alpha channel
1190// TODO: move definition for device-specific range into
1191// hardware.h, instead of using hard-coded values here.
1192#define HARDWARE_IS_DEVICE_FORMAT(f) ((f) >= 0x100 && (f) <= 0x1FF)
1193
1194bool Layer::getOpacityForFormat(uint32_t format) {
1195    if (HARDWARE_IS_DEVICE_FORMAT(format)) {
1196        return true;
1197    }
1198    switch (format) {
1199        case HAL_PIXEL_FORMAT_RGBA_8888:
1200        case HAL_PIXEL_FORMAT_BGRA_8888:
1201            return false;
1202    }
1203    // in all other case, we have no blending (also for unknown formats)
1204    return true;
1205}
1206
1207// ----------------------------------------------------------------------------
1208// local state
1209// ----------------------------------------------------------------------------
1210
1211static void boundPoint(vec2* point, const Rect& crop) {
1212    if (point->x < crop.left) {
1213        point->x = crop.left;
1214    }
1215    if (point->x > crop.right) {
1216        point->x = crop.right;
1217    }
1218    if (point->y < crop.top) {
1219        point->y = crop.top;
1220    }
1221    if (point->y > crop.bottom) {
1222        point->y = crop.bottom;
1223    }
1224}
1225
1226void Layer::computeGeometry(const sp<const DisplayDevice>& hw, Mesh& mesh,
1227        bool useIdentityTransform) const
1228{
1229    const Layer::State& s(getDrawingState());
1230    const Transform tr(hw->getTransform());
1231    const uint32_t hw_h = hw->getHeight();
1232    Rect win(s.active.w, s.active.h);
1233    if (!s.crop.isEmpty()) {
1234        win.intersect(s.crop, &win);
1235    }
1236    // subtract the transparent region and snap to the bounds
1237    win = reduce(win, s.activeTransparentRegion);
1238
1239    vec2 lt = vec2(win.left, win.top);
1240    vec2 lb = vec2(win.left, win.bottom);
1241    vec2 rb = vec2(win.right, win.bottom);
1242    vec2 rt = vec2(win.right, win.top);
1243
1244    if (!useIdentityTransform) {
1245        lt = s.active.transform.transform(lt);
1246        lb = s.active.transform.transform(lb);
1247        rb = s.active.transform.transform(rb);
1248        rt = s.active.transform.transform(rt);
1249    }
1250
1251    if (!s.finalCrop.isEmpty()) {
1252        boundPoint(&lt, s.finalCrop);
1253        boundPoint(&lb, s.finalCrop);
1254        boundPoint(&rb, s.finalCrop);
1255        boundPoint(&rt, s.finalCrop);
1256    }
1257
1258    Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());
1259    position[0] = tr.transform(lt);
1260    position[1] = tr.transform(lb);
1261    position[2] = tr.transform(rb);
1262    position[3] = tr.transform(rt);
1263    for (size_t i=0 ; i<4 ; i++) {
1264        position[i].y = hw_h - position[i].y;
1265    }
1266}
1267
1268bool Layer::isOpaque(const Layer::State& s) const
1269{
1270    // if we don't have a buffer yet, we're translucent regardless of the
1271    // layer's opaque flag.
1272    if (mActiveBuffer == 0) {
1273        return false;
1274    }
1275
1276    // if the layer has the opaque flag, then we're always opaque,
1277    // otherwise we use the current buffer's format.
1278    return ((s.flags & layer_state_t::eLayerOpaque) != 0) || mCurrentOpacity;
1279}
1280
1281bool Layer::isSecure() const
1282{
1283    const Layer::State& s(mDrawingState);
1284    return (s.flags & layer_state_t::eLayerSecure);
1285}
1286
1287bool Layer::isProtected() const
1288{
1289    const sp<GraphicBuffer>& activeBuffer(mActiveBuffer);
1290    return (activeBuffer != 0) &&
1291            (activeBuffer->getUsage() & GRALLOC_USAGE_PROTECTED);
1292}
1293
1294bool Layer::isFixedSize() const {
1295    return getEffectiveScalingMode() != NATIVE_WINDOW_SCALING_MODE_FREEZE;
1296}
1297
1298bool Layer::isCropped() const {
1299    return !mCurrentCrop.isEmpty();
1300}
1301
1302bool Layer::needsFiltering(const sp<const DisplayDevice>& hw) const {
1303    return mNeedsFiltering || hw->needsFiltering();
1304}
1305
1306void Layer::setVisibleRegion(const Region& visibleRegion) {
1307    // always called from main thread
1308    this->visibleRegion = visibleRegion;
1309}
1310
1311void Layer::setCoveredRegion(const Region& coveredRegion) {
1312    // always called from main thread
1313    this->coveredRegion = coveredRegion;
1314}
1315
1316void Layer::setVisibleNonTransparentRegion(const Region&
1317        setVisibleNonTransparentRegion) {
1318    // always called from main thread
1319    this->visibleNonTransparentRegion = setVisibleNonTransparentRegion;
1320}
1321
1322// ----------------------------------------------------------------------------
1323// transaction
1324// ----------------------------------------------------------------------------
1325
1326void Layer::pushPendingState() {
1327    if (!mCurrentState.modified) {
1328        return;
1329    }
1330
1331    // If this transaction is waiting on the receipt of a frame, generate a sync
1332    // point and send it to the remote layer.
1333    if (mCurrentState.handle != nullptr) {
1334        sp<Handle> handle = static_cast<Handle*>(mCurrentState.handle.get());
1335        sp<Layer> handleLayer = handle->owner.promote();
1336        if (handleLayer == nullptr) {
1337            ALOGE("[%s] Unable to promote Layer handle", mName.string());
1338            // If we can't promote the layer we are intended to wait on,
1339            // then it is expired or otherwise invalid. Allow this transaction
1340            // to be applied as per normal (no synchronization).
1341            mCurrentState.handle = nullptr;
1342        } else {
1343            auto syncPoint = std::make_shared<SyncPoint>(
1344                    mCurrentState.frameNumber);
1345            if (handleLayer->addSyncPoint(syncPoint)) {
1346                mRemoteSyncPoints.push_back(std::move(syncPoint));
1347            } else {
1348                // We already missed the frame we're supposed to synchronize
1349                // on, so go ahead and apply the state update
1350                mCurrentState.handle = nullptr;
1351            }
1352        }
1353
1354        // Wake us up to check if the frame has been received
1355        setTransactionFlags(eTransactionNeeded);
1356    }
1357    mPendingStates.push_back(mCurrentState);
1358}
1359
1360void Layer::popPendingState(State* stateToCommit) {
1361    auto oldFlags = stateToCommit->flags;
1362    *stateToCommit = mPendingStates[0];
1363    stateToCommit->flags = (oldFlags & ~stateToCommit->mask) |
1364            (stateToCommit->flags & stateToCommit->mask);
1365
1366    mPendingStates.removeAt(0);
1367}
1368
1369bool Layer::applyPendingStates(State* stateToCommit) {
1370    bool stateUpdateAvailable = false;
1371    while (!mPendingStates.empty()) {
1372        if (mPendingStates[0].handle != nullptr) {
1373            if (mRemoteSyncPoints.empty()) {
1374                // If we don't have a sync point for this, apply it anyway. It
1375                // will be visually wrong, but it should keep us from getting
1376                // into too much trouble.
1377                ALOGE("[%s] No local sync point found", mName.string());
1378                popPendingState(stateToCommit);
1379                stateUpdateAvailable = true;
1380                continue;
1381            }
1382
1383            if (mRemoteSyncPoints.front()->getFrameNumber() !=
1384                    mPendingStates[0].frameNumber) {
1385                ALOGE("[%s] Unexpected sync point frame number found",
1386                        mName.string());
1387
1388                // Signal our end of the sync point and then dispose of it
1389                mRemoteSyncPoints.front()->setTransactionApplied();
1390                mRemoteSyncPoints.pop_front();
1391                continue;
1392            }
1393
1394            if (mRemoteSyncPoints.front()->frameIsAvailable()) {
1395                // Apply the state update
1396                popPendingState(stateToCommit);
1397                stateUpdateAvailable = true;
1398
1399                // Signal our end of the sync point and then dispose of it
1400                mRemoteSyncPoints.front()->setTransactionApplied();
1401                mRemoteSyncPoints.pop_front();
1402            } else {
1403                break;
1404            }
1405        } else {
1406            popPendingState(stateToCommit);
1407            stateUpdateAvailable = true;
1408        }
1409    }
1410
1411    // If we still have pending updates, wake SurfaceFlinger back up and point
1412    // it at this layer so we can process them
1413    if (!mPendingStates.empty()) {
1414        setTransactionFlags(eTransactionNeeded);
1415        mFlinger->setTransactionFlags(eTraversalNeeded);
1416    }
1417
1418    mCurrentState.modified = false;
1419    return stateUpdateAvailable;
1420}
1421
1422void Layer::notifyAvailableFrames() {
1423    auto headFrameNumber = getHeadFrameNumber();
1424    bool headFenceSignaled = headFenceHasSignaled();
1425    Mutex::Autolock lock(mLocalSyncPointMutex);
1426    for (auto& point : mLocalSyncPoints) {
1427        if (headFrameNumber >= point->getFrameNumber() && headFenceSignaled) {
1428            point->setFrameAvailable();
1429        }
1430    }
1431}
1432
1433uint32_t Layer::doTransaction(uint32_t flags) {
1434    ATRACE_CALL();
1435
1436    pushPendingState();
1437    Layer::State c = getCurrentState();
1438    if (!applyPendingStates(&c)) {
1439        return 0;
1440    }
1441
1442    const Layer::State& s(getDrawingState());
1443
1444    const bool sizeChanged = (c.requested.w != s.requested.w) ||
1445                             (c.requested.h != s.requested.h);
1446
1447    if (sizeChanged) {
1448        // the size changed, we need to ask our client to request a new buffer
1449        ALOGD_IF(DEBUG_RESIZE,
1450                "doTransaction: geometry (layer=%p '%s'), tr=%02x, scalingMode=%d\n"
1451                "  current={ active   ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n"
1452                "            requested={ wh={%4u,%4u} }}\n"
1453                "  drawing={ active   ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n"
1454                "            requested={ wh={%4u,%4u} }}\n",
1455                this, getName().string(), mCurrentTransform,
1456                getEffectiveScalingMode(),
1457                c.active.w, c.active.h,
1458                c.crop.left,
1459                c.crop.top,
1460                c.crop.right,
1461                c.crop.bottom,
1462                c.crop.getWidth(),
1463                c.crop.getHeight(),
1464                c.requested.w, c.requested.h,
1465                s.active.w, s.active.h,
1466                s.crop.left,
1467                s.crop.top,
1468                s.crop.right,
1469                s.crop.bottom,
1470                s.crop.getWidth(),
1471                s.crop.getHeight(),
1472                s.requested.w, s.requested.h);
1473
1474        // record the new size, form this point on, when the client request
1475        // a buffer, it'll get the new size.
1476        mSurfaceFlingerConsumer->setDefaultBufferSize(
1477                c.requested.w, c.requested.h);
1478    }
1479
1480    const bool resizePending = (c.requested.w != c.active.w) ||
1481            (c.requested.h != c.active.h);
1482    if (!isFixedSize()) {
1483        if (resizePending && mSidebandStream == NULL) {
1484            // don't let Layer::doTransaction update the drawing state
1485            // if we have a pending resize, unless we are in fixed-size mode.
1486            // the drawing state will be updated only once we receive a buffer
1487            // with the correct size.
1488            //
1489            // in particular, we want to make sure the clip (which is part
1490            // of the geometry state) is latched together with the size but is
1491            // latched immediately when no resizing is involved.
1492            //
1493            // If a sideband stream is attached, however, we want to skip this
1494            // optimization so that transactions aren't missed when a buffer
1495            // never arrives
1496
1497            flags |= eDontUpdateGeometryState;
1498        }
1499    }
1500
1501    // always set active to requested, unless we're asked not to
1502    // this is used by Layer, which special cases resizes.
1503    if (flags & eDontUpdateGeometryState)  {
1504    } else {
1505        Layer::State& editCurrentState(getCurrentState());
1506        if (mFreezePositionUpdates) {
1507            float tx = c.active.transform.tx();
1508            float ty = c.active.transform.ty();
1509            c.active = c.requested;
1510            c.active.transform.set(tx, ty);
1511            editCurrentState.active = c.active;
1512        } else {
1513            editCurrentState.active = editCurrentState.requested;
1514            c.active = c.requested;
1515        }
1516    }
1517
1518    if (s.active != c.active) {
1519        // invalidate and recompute the visible regions if needed
1520        flags |= Layer::eVisibleRegion;
1521    }
1522
1523    if (c.sequence != s.sequence) {
1524        // invalidate and recompute the visible regions if needed
1525        flags |= eVisibleRegion;
1526        this->contentDirty = true;
1527
1528        // we may use linear filtering, if the matrix scales us
1529        const uint8_t type = c.active.transform.getType();
1530        mNeedsFiltering = (!c.active.transform.preserveRects() ||
1531                (type >= Transform::SCALE));
1532    }
1533
1534    // If the layer is hidden, signal and clear out all local sync points so
1535    // that transactions for layers depending on this layer's frames becoming
1536    // visible are not blocked
1537    if (c.flags & layer_state_t::eLayerHidden) {
1538        Mutex::Autolock lock(mLocalSyncPointMutex);
1539        for (auto& point : mLocalSyncPoints) {
1540            point->setFrameAvailable();
1541        }
1542        mLocalSyncPoints.clear();
1543    }
1544
1545    // Commit the transaction
1546    commitTransaction(c);
1547    return flags;
1548}
1549
1550void Layer::commitTransaction(const State& stateToCommit) {
1551    mDrawingState = stateToCommit;
1552}
1553
1554uint32_t Layer::getTransactionFlags(uint32_t flags) {
1555    return android_atomic_and(~flags, &mTransactionFlags) & flags;
1556}
1557
1558uint32_t Layer::setTransactionFlags(uint32_t flags) {
1559    return android_atomic_or(flags, &mTransactionFlags);
1560}
1561
1562bool Layer::setPosition(float x, float y, bool immediate) {
1563    if (mCurrentState.requested.transform.tx() == x && mCurrentState.requested.transform.ty() == y)
1564        return false;
1565    mCurrentState.sequence++;
1566
1567    // We update the requested and active position simultaneously because
1568    // we want to apply the position portion of the transform matrix immediately,
1569    // but still delay scaling when resizing a SCALING_MODE_FREEZE layer.
1570    mCurrentState.requested.transform.set(x, y);
1571    if (immediate && !mFreezePositionUpdates) {
1572        mCurrentState.active.transform.set(x, y);
1573    }
1574    mFreezePositionUpdates = mFreezePositionUpdates || !immediate;
1575
1576    mCurrentState.modified = true;
1577    setTransactionFlags(eTransactionNeeded);
1578    return true;
1579}
1580
1581bool Layer::setLayer(uint32_t z) {
1582    if (mCurrentState.z == z)
1583        return false;
1584    mCurrentState.sequence++;
1585    mCurrentState.z = z;
1586    mCurrentState.modified = true;
1587    setTransactionFlags(eTransactionNeeded);
1588    return true;
1589}
1590bool Layer::setSize(uint32_t w, uint32_t h) {
1591    if (mCurrentState.requested.w == w && mCurrentState.requested.h == h)
1592        return false;
1593    mCurrentState.requested.w = w;
1594    mCurrentState.requested.h = h;
1595    mCurrentState.modified = true;
1596    setTransactionFlags(eTransactionNeeded);
1597    return true;
1598}
1599#ifdef USE_HWC2
1600bool Layer::setAlpha(float alpha) {
1601#else
1602bool Layer::setAlpha(uint8_t alpha) {
1603#endif
1604    if (mCurrentState.alpha == alpha)
1605        return false;
1606    mCurrentState.sequence++;
1607    mCurrentState.alpha = alpha;
1608    mCurrentState.modified = true;
1609    setTransactionFlags(eTransactionNeeded);
1610    return true;
1611}
1612bool Layer::setMatrix(const layer_state_t::matrix22_t& matrix) {
1613    mCurrentState.sequence++;
1614    mCurrentState.requested.transform.set(
1615            matrix.dsdx, matrix.dsdy, matrix.dtdx, matrix.dtdy);
1616    mCurrentState.modified = true;
1617    setTransactionFlags(eTransactionNeeded);
1618    return true;
1619}
1620bool Layer::setTransparentRegionHint(const Region& transparent) {
1621    mCurrentState.requestedTransparentRegion = transparent;
1622    mCurrentState.modified = true;
1623    setTransactionFlags(eTransactionNeeded);
1624    return true;
1625}
1626bool Layer::setFlags(uint8_t flags, uint8_t mask) {
1627    const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask);
1628    if (mCurrentState.flags == newFlags)
1629        return false;
1630    mCurrentState.sequence++;
1631    mCurrentState.flags = newFlags;
1632    mCurrentState.mask = mask;
1633    mCurrentState.modified = true;
1634    setTransactionFlags(eTransactionNeeded);
1635    return true;
1636}
1637
1638bool Layer::setCrop(const Rect& crop, bool immediate) {
1639    if (mCurrentState.crop == crop)
1640        return false;
1641    mCurrentState.sequence++;
1642    mCurrentState.requestedCrop = crop;
1643    if (immediate) {
1644        mCurrentState.crop = crop;
1645    }
1646    mCurrentState.modified = true;
1647    setTransactionFlags(eTransactionNeeded);
1648    return true;
1649}
1650bool Layer::setFinalCrop(const Rect& crop) {
1651    if (mCurrentState.finalCrop == crop)
1652        return false;
1653    mCurrentState.sequence++;
1654    mCurrentState.finalCrop = crop;
1655    mCurrentState.modified = true;
1656    setTransactionFlags(eTransactionNeeded);
1657    return true;
1658}
1659
1660bool Layer::setOverrideScalingMode(int32_t scalingMode) {
1661    if (scalingMode == mOverrideScalingMode)
1662        return false;
1663    mOverrideScalingMode = scalingMode;
1664    setTransactionFlags(eTransactionNeeded);
1665    return true;
1666}
1667
1668uint32_t Layer::getEffectiveScalingMode() const {
1669    if (mOverrideScalingMode >= 0) {
1670      return mOverrideScalingMode;
1671    }
1672    return mCurrentScalingMode;
1673}
1674
1675bool Layer::setLayerStack(uint32_t layerStack) {
1676    if (mCurrentState.layerStack == layerStack)
1677        return false;
1678    mCurrentState.sequence++;
1679    mCurrentState.layerStack = layerStack;
1680    mCurrentState.modified = true;
1681    setTransactionFlags(eTransactionNeeded);
1682    return true;
1683}
1684
1685void Layer::deferTransactionUntil(const sp<IBinder>& handle,
1686        uint64_t frameNumber) {
1687    mCurrentState.handle = handle;
1688    mCurrentState.frameNumber = frameNumber;
1689    // We don't set eTransactionNeeded, because just receiving a deferral
1690    // request without any other state updates shouldn't actually induce a delay
1691    mCurrentState.modified = true;
1692    pushPendingState();
1693    mCurrentState.handle = nullptr;
1694    mCurrentState.frameNumber = 0;
1695    mCurrentState.modified = false;
1696}
1697
1698void Layer::useSurfaceDamage() {
1699    if (mFlinger->mForceFullDamage) {
1700        surfaceDamageRegion = Region::INVALID_REGION;
1701    } else {
1702        surfaceDamageRegion = mSurfaceFlingerConsumer->getSurfaceDamage();
1703    }
1704}
1705
1706void Layer::useEmptyDamage() {
1707    surfaceDamageRegion.clear();
1708}
1709
1710// ----------------------------------------------------------------------------
1711// pageflip handling...
1712// ----------------------------------------------------------------------------
1713
1714bool Layer::shouldPresentNow(const DispSync& dispSync) const {
1715    if (mSidebandStreamChanged || mAutoRefresh) {
1716        return true;
1717    }
1718
1719    Mutex::Autolock lock(mQueueItemLock);
1720    if (mQueueItems.empty()) {
1721        return false;
1722    }
1723    auto timestamp = mQueueItems[0].mTimestamp;
1724    nsecs_t expectedPresent =
1725            mSurfaceFlingerConsumer->computeExpectedPresent(dispSync);
1726
1727    // Ignore timestamps more than a second in the future
1728    bool isPlausible = timestamp < (expectedPresent + s2ns(1));
1729    ALOGW_IF(!isPlausible, "[%s] Timestamp %" PRId64 " seems implausible "
1730            "relative to expectedPresent %" PRId64, mName.string(), timestamp,
1731            expectedPresent);
1732
1733    bool isDue = timestamp < expectedPresent;
1734    return isDue || !isPlausible;
1735}
1736
1737bool Layer::onPreComposition() {
1738    mRefreshPending = false;
1739    return mQueuedFrames > 0 || mSidebandStreamChanged || mAutoRefresh;
1740}
1741
1742bool Layer::onPostComposition() {
1743    bool frameLatencyNeeded = mFrameLatencyNeeded;
1744    if (mFrameLatencyNeeded) {
1745        nsecs_t desiredPresentTime = mSurfaceFlingerConsumer->getTimestamp();
1746        mFrameTracker.setDesiredPresentTime(desiredPresentTime);
1747
1748        sp<Fence> frameReadyFence = mSurfaceFlingerConsumer->getCurrentFence();
1749        if (frameReadyFence->isValid()) {
1750            mFrameTracker.setFrameReadyFence(frameReadyFence);
1751        } else {
1752            // There was no fence for this frame, so assume that it was ready
1753            // to be presented at the desired present time.
1754            mFrameTracker.setFrameReadyTime(desiredPresentTime);
1755        }
1756
1757        const HWComposer& hwc = mFlinger->getHwComposer();
1758#ifdef USE_HWC2
1759        sp<Fence> presentFence = hwc.getRetireFence(HWC_DISPLAY_PRIMARY);
1760#else
1761        sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY);
1762#endif
1763        if (presentFence->isValid()) {
1764            mFrameTracker.setActualPresentFence(presentFence);
1765        } else {
1766            // The HWC doesn't support present fences, so use the refresh
1767            // timestamp instead.
1768            nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY);
1769            mFrameTracker.setActualPresentTime(presentTime);
1770        }
1771
1772        mFrameTracker.advanceFrame();
1773        mFrameLatencyNeeded = false;
1774    }
1775    return frameLatencyNeeded;
1776}
1777
1778#ifdef USE_HWC2
1779void Layer::releasePendingBuffer() {
1780    mSurfaceFlingerConsumer->releasePendingBuffer();
1781}
1782#endif
1783
1784bool Layer::isVisible() const {
1785    const Layer::State& s(mDrawingState);
1786#ifdef USE_HWC2
1787    return !(s.flags & layer_state_t::eLayerHidden) && s.alpha > 0.0f
1788            && (mActiveBuffer != NULL || mSidebandStream != NULL);
1789#else
1790    return !(s.flags & layer_state_t::eLayerHidden) && s.alpha
1791            && (mActiveBuffer != NULL || mSidebandStream != NULL);
1792#endif
1793}
1794
1795Region Layer::latchBuffer(bool& recomputeVisibleRegions)
1796{
1797    ATRACE_CALL();
1798
1799    if (android_atomic_acquire_cas(true, false, &mSidebandStreamChanged) == 0) {
1800        // mSidebandStreamChanged was true
1801        mSidebandStream = mSurfaceFlingerConsumer->getSidebandStream();
1802        if (mSidebandStream != NULL) {
1803            setTransactionFlags(eTransactionNeeded);
1804            mFlinger->setTransactionFlags(eTraversalNeeded);
1805        }
1806        recomputeVisibleRegions = true;
1807
1808        const State& s(getDrawingState());
1809        return s.active.transform.transform(Region(Rect(s.active.w, s.active.h)));
1810    }
1811
1812    Region outDirtyRegion;
1813    if (mQueuedFrames > 0 || mAutoRefresh) {
1814
1815        // if we've already called updateTexImage() without going through
1816        // a composition step, we have to skip this layer at this point
1817        // because we cannot call updateTeximage() without a corresponding
1818        // compositionComplete() call.
1819        // we'll trigger an update in onPreComposition().
1820        if (mRefreshPending) {
1821            return outDirtyRegion;
1822        }
1823
1824        // If the head buffer's acquire fence hasn't signaled yet, return and
1825        // try again later
1826        if (!headFenceHasSignaled()) {
1827            mFlinger->signalLayerUpdate();
1828            return outDirtyRegion;
1829        }
1830
1831        // Capture the old state of the layer for comparisons later
1832        const State& s(getDrawingState());
1833        const bool oldOpacity = isOpaque(s);
1834        sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer;
1835
1836        struct Reject : public SurfaceFlingerConsumer::BufferRejecter {
1837            Layer::State& front;
1838            Layer::State& current;
1839            bool& recomputeVisibleRegions;
1840            bool stickyTransformSet;
1841            const char* name;
1842            int32_t overrideScalingMode;
1843            bool& freezePositionUpdates;
1844
1845            Reject(Layer::State& front, Layer::State& current,
1846                    bool& recomputeVisibleRegions, bool stickySet,
1847                    const char* name,
1848                    int32_t overrideScalingMode,
1849                    bool& freezePositionUpdates)
1850                : front(front), current(current),
1851                  recomputeVisibleRegions(recomputeVisibleRegions),
1852                  stickyTransformSet(stickySet),
1853                  name(name),
1854                  overrideScalingMode(overrideScalingMode),
1855                  freezePositionUpdates(freezePositionUpdates) {
1856            }
1857
1858            virtual bool reject(const sp<GraphicBuffer>& buf,
1859                    const BufferItem& item) {
1860                if (buf == NULL) {
1861                    return false;
1862                }
1863
1864                uint32_t bufWidth  = buf->getWidth();
1865                uint32_t bufHeight = buf->getHeight();
1866
1867                // check that we received a buffer of the right size
1868                // (Take the buffer's orientation into account)
1869                if (item.mTransform & Transform::ROT_90) {
1870                    swap(bufWidth, bufHeight);
1871                }
1872
1873                int actualScalingMode = overrideScalingMode >= 0 ?
1874                        overrideScalingMode : item.mScalingMode;
1875                bool isFixedSize = actualScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE;
1876                if (front.active != front.requested) {
1877
1878                    if (isFixedSize ||
1879                            (bufWidth == front.requested.w &&
1880                             bufHeight == front.requested.h))
1881                    {
1882                        // Here we pretend the transaction happened by updating the
1883                        // current and drawing states. Drawing state is only accessed
1884                        // in this thread, no need to have it locked
1885                        front.active = front.requested;
1886
1887                        // We also need to update the current state so that
1888                        // we don't end-up overwriting the drawing state with
1889                        // this stale current state during the next transaction
1890                        //
1891                        // NOTE: We don't need to hold the transaction lock here
1892                        // because State::active is only accessed from this thread.
1893                        current.active = front.active;
1894                        current.modified = true;
1895
1896                        // recompute visible region
1897                        recomputeVisibleRegions = true;
1898                    }
1899
1900                    ALOGD_IF(DEBUG_RESIZE,
1901                            "[%s] latchBuffer/reject: buffer (%ux%u, tr=%02x), scalingMode=%d\n"
1902                            "  drawing={ active   ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n"
1903                            "            requested={ wh={%4u,%4u} }}\n",
1904                            name,
1905                            bufWidth, bufHeight, item.mTransform, item.mScalingMode,
1906                            front.active.w, front.active.h,
1907                            front.crop.left,
1908                            front.crop.top,
1909                            front.crop.right,
1910                            front.crop.bottom,
1911                            front.crop.getWidth(),
1912                            front.crop.getHeight(),
1913                            front.requested.w, front.requested.h);
1914                }
1915
1916                if (!isFixedSize && !stickyTransformSet) {
1917                    if (front.active.w != bufWidth ||
1918                        front.active.h != bufHeight) {
1919                        // reject this buffer
1920                        ALOGE("[%s] rejecting buffer: "
1921                                "bufWidth=%d, bufHeight=%d, front.active.{w=%d, h=%d}",
1922                                name, bufWidth, bufHeight, front.active.w, front.active.h);
1923                        return true;
1924                    }
1925                }
1926
1927                // if the transparent region has changed (this test is
1928                // conservative, but that's fine, worst case we're doing
1929                // a bit of extra work), we latch the new one and we
1930                // trigger a visible-region recompute.
1931                if (!front.activeTransparentRegion.isTriviallyEqual(
1932                        front.requestedTransparentRegion)) {
1933                    front.activeTransparentRegion = front.requestedTransparentRegion;
1934
1935                    // We also need to update the current state so that
1936                    // we don't end-up overwriting the drawing state with
1937                    // this stale current state during the next transaction
1938                    //
1939                    // NOTE: We don't need to hold the transaction lock here
1940                    // because State::active is only accessed from this thread.
1941                    current.activeTransparentRegion = front.activeTransparentRegion;
1942
1943                    // recompute visible region
1944                    recomputeVisibleRegions = true;
1945                }
1946
1947                if (front.crop != front.requestedCrop) {
1948                    front.crop = front.requestedCrop;
1949                    current.crop = front.requestedCrop;
1950                    recomputeVisibleRegions = true;
1951                }
1952                freezePositionUpdates = false;
1953
1954                return false;
1955            }
1956        };
1957
1958        Reject r(mDrawingState, getCurrentState(), recomputeVisibleRegions,
1959                getProducerStickyTransform() != 0, mName.string(),
1960                mOverrideScalingMode, mFreezePositionUpdates);
1961
1962
1963        // Check all of our local sync points to ensure that all transactions
1964        // which need to have been applied prior to the frame which is about to
1965        // be latched have signaled
1966
1967        auto headFrameNumber = getHeadFrameNumber();
1968        bool matchingFramesFound = false;
1969        bool allTransactionsApplied = true;
1970        {
1971            Mutex::Autolock lock(mLocalSyncPointMutex);
1972            for (auto& point : mLocalSyncPoints) {
1973                if (point->getFrameNumber() > headFrameNumber) {
1974                    break;
1975                }
1976
1977                matchingFramesFound = true;
1978
1979                if (!point->frameIsAvailable()) {
1980                    // We haven't notified the remote layer that the frame for
1981                    // this point is available yet. Notify it now, and then
1982                    // abort this attempt to latch.
1983                    point->setFrameAvailable();
1984                    allTransactionsApplied = false;
1985                    break;
1986                }
1987
1988                allTransactionsApplied &= point->transactionIsApplied();
1989            }
1990        }
1991
1992        if (matchingFramesFound && !allTransactionsApplied) {
1993            mFlinger->signalLayerUpdate();
1994            return outDirtyRegion;
1995        }
1996
1997        // This boolean is used to make sure that SurfaceFlinger's shadow copy
1998        // of the buffer queue isn't modified when the buffer queue is returning
1999        // BufferItem's that weren't actually queued. This can happen in shared
2000        // buffer mode.
2001        bool queuedBuffer = false;
2002        status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r,
2003                mFlinger->mPrimaryDispSync, &mAutoRefresh, &queuedBuffer,
2004                mLastFrameNumberReceived);
2005        if (updateResult == BufferQueue::PRESENT_LATER) {
2006            // Producer doesn't want buffer to be displayed yet.  Signal a
2007            // layer update so we check again at the next opportunity.
2008            mFlinger->signalLayerUpdate();
2009            return outDirtyRegion;
2010        } else if (updateResult == SurfaceFlingerConsumer::BUFFER_REJECTED) {
2011            // If the buffer has been rejected, remove it from the shadow queue
2012            // and return early
2013            if (queuedBuffer) {
2014                Mutex::Autolock lock(mQueueItemLock);
2015                mQueueItems.removeAt(0);
2016                android_atomic_dec(&mQueuedFrames);
2017            }
2018            return outDirtyRegion;
2019        } else if (updateResult != NO_ERROR || mUpdateTexImageFailed) {
2020            // This can occur if something goes wrong when trying to create the
2021            // EGLImage for this buffer. If this happens, the buffer has already
2022            // been released, so we need to clean up the queue and bug out
2023            // early.
2024            if (queuedBuffer) {
2025                Mutex::Autolock lock(mQueueItemLock);
2026                mQueueItems.clear();
2027                android_atomic_and(0, &mQueuedFrames);
2028            }
2029
2030            // Once we have hit this state, the shadow queue may no longer
2031            // correctly reflect the incoming BufferQueue's contents, so even if
2032            // updateTexImage starts working, the only safe course of action is
2033            // to continue to ignore updates.
2034            mUpdateTexImageFailed = true;
2035
2036            return outDirtyRegion;
2037        }
2038
2039        if (queuedBuffer) {
2040            // Autolock scope
2041            auto currentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber();
2042
2043            Mutex::Autolock lock(mQueueItemLock);
2044
2045            // Remove any stale buffers that have been dropped during
2046            // updateTexImage
2047            while (mQueueItems[0].mFrameNumber != currentFrameNumber) {
2048                mQueueItems.removeAt(0);
2049                android_atomic_dec(&mQueuedFrames);
2050            }
2051
2052            mQueueItems.removeAt(0);
2053        }
2054
2055
2056        // Decrement the queued-frames count.  Signal another event if we
2057        // have more frames pending.
2058        if ((queuedBuffer && android_atomic_dec(&mQueuedFrames) > 1)
2059                || mAutoRefresh) {
2060            mFlinger->signalLayerUpdate();
2061        }
2062
2063        if (updateResult != NO_ERROR) {
2064            // something happened!
2065            recomputeVisibleRegions = true;
2066            return outDirtyRegion;
2067        }
2068
2069        // update the active buffer
2070        mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer();
2071        if (mActiveBuffer == NULL) {
2072            // this can only happen if the very first buffer was rejected.
2073            return outDirtyRegion;
2074        }
2075
2076        mRefreshPending = true;
2077        mFrameLatencyNeeded = true;
2078        if (oldActiveBuffer == NULL) {
2079             // the first time we receive a buffer, we need to trigger a
2080             // geometry invalidation.
2081            recomputeVisibleRegions = true;
2082         }
2083
2084        Rect crop(mSurfaceFlingerConsumer->getCurrentCrop());
2085        const uint32_t transform(mSurfaceFlingerConsumer->getCurrentTransform());
2086        const uint32_t scalingMode(mSurfaceFlingerConsumer->getCurrentScalingMode());
2087        if ((crop != mCurrentCrop) ||
2088            (transform != mCurrentTransform) ||
2089            (scalingMode != mCurrentScalingMode))
2090        {
2091            mCurrentCrop = crop;
2092            mCurrentTransform = transform;
2093            mCurrentScalingMode = scalingMode;
2094            recomputeVisibleRegions = true;
2095        }
2096
2097        if (oldActiveBuffer != NULL) {
2098            uint32_t bufWidth  = mActiveBuffer->getWidth();
2099            uint32_t bufHeight = mActiveBuffer->getHeight();
2100            if (bufWidth != uint32_t(oldActiveBuffer->width) ||
2101                bufHeight != uint32_t(oldActiveBuffer->height)) {
2102                recomputeVisibleRegions = true;
2103            }
2104        }
2105
2106        mCurrentOpacity = getOpacityForFormat(mActiveBuffer->format);
2107        if (oldOpacity != isOpaque(s)) {
2108            recomputeVisibleRegions = true;
2109        }
2110
2111        mCurrentFrameNumber = mSurfaceFlingerConsumer->getFrameNumber();
2112
2113        // Remove any sync points corresponding to the buffer which was just
2114        // latched
2115        {
2116            Mutex::Autolock lock(mLocalSyncPointMutex);
2117            auto point = mLocalSyncPoints.begin();
2118            while (point != mLocalSyncPoints.end()) {
2119                if (!(*point)->frameIsAvailable() ||
2120                        !(*point)->transactionIsApplied()) {
2121                    // This sync point must have been added since we started
2122                    // latching. Don't drop it yet.
2123                    ++point;
2124                    continue;
2125                }
2126
2127                if ((*point)->getFrameNumber() <= mCurrentFrameNumber) {
2128                    point = mLocalSyncPoints.erase(point);
2129                } else {
2130                    ++point;
2131                }
2132            }
2133        }
2134
2135        // FIXME: postedRegion should be dirty & bounds
2136        Region dirtyRegion(Rect(s.active.w, s.active.h));
2137
2138        // transform the dirty region to window-manager space
2139        outDirtyRegion = (s.active.transform.transform(dirtyRegion));
2140    }
2141    return outDirtyRegion;
2142}
2143
2144uint32_t Layer::getEffectiveUsage(uint32_t usage) const
2145{
2146    // TODO: should we do something special if mSecure is set?
2147    if (mProtectedByApp) {
2148        // need a hardware-protected path to external video sink
2149        usage |= GraphicBuffer::USAGE_PROTECTED;
2150    }
2151    if (mPotentialCursor) {
2152        usage |= GraphicBuffer::USAGE_CURSOR;
2153    }
2154    usage |= GraphicBuffer::USAGE_HW_COMPOSER;
2155    return usage;
2156}
2157
2158void Layer::updateTransformHint(const sp<const DisplayDevice>& hw) const {
2159    uint32_t orientation = 0;
2160    if (!mFlinger->mDebugDisableTransformHint) {
2161        // The transform hint is used to improve performance, but we can
2162        // only have a single transform hint, it cannot
2163        // apply to all displays.
2164        const Transform& planeTransform(hw->getTransform());
2165        orientation = planeTransform.getOrientation();
2166        if (orientation & Transform::ROT_INVALID) {
2167            orientation = 0;
2168        }
2169    }
2170    mSurfaceFlingerConsumer->setTransformHint(orientation);
2171}
2172
2173// ----------------------------------------------------------------------------
2174// debugging
2175// ----------------------------------------------------------------------------
2176
2177void Layer::dump(String8& result, Colorizer& colorizer) const
2178{
2179    const Layer::State& s(getDrawingState());
2180
2181    colorizer.colorize(result, Colorizer::GREEN);
2182    result.appendFormat(
2183            "+ %s %p (%s)\n",
2184            getTypeId(), this, getName().string());
2185    colorizer.reset(result);
2186
2187    s.activeTransparentRegion.dump(result, "transparentRegion");
2188    visibleRegion.dump(result, "visibleRegion");
2189    surfaceDamageRegion.dump(result, "surfaceDamageRegion");
2190    sp<Client> client(mClientRef.promote());
2191
2192    result.appendFormat(            "      "
2193            "layerStack=%4d, z=%9d, pos=(%g,%g), size=(%4d,%4d), "
2194            "crop=(%4d,%4d,%4d,%4d), finalCrop=(%4d,%4d,%4d,%4d), "
2195            "isOpaque=%1d, invalidate=%1d, "
2196#ifdef USE_HWC2
2197            "alpha=%.3f, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n"
2198#else
2199            "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n"
2200#endif
2201            "      client=%p\n",
2202            s.layerStack, s.z, s.active.transform.tx(), s.active.transform.ty(), s.active.w, s.active.h,
2203            s.crop.left, s.crop.top,
2204            s.crop.right, s.crop.bottom,
2205            s.finalCrop.left, s.finalCrop.top,
2206            s.finalCrop.right, s.finalCrop.bottom,
2207            isOpaque(s), contentDirty,
2208            s.alpha, s.flags,
2209            s.active.transform[0][0], s.active.transform[0][1],
2210            s.active.transform[1][0], s.active.transform[1][1],
2211            client.get());
2212
2213    sp<const GraphicBuffer> buf0(mActiveBuffer);
2214    uint32_t w0=0, h0=0, s0=0, f0=0;
2215    if (buf0 != 0) {
2216        w0 = buf0->getWidth();
2217        h0 = buf0->getHeight();
2218        s0 = buf0->getStride();
2219        f0 = buf0->format;
2220    }
2221    result.appendFormat(
2222            "      "
2223            "format=%2d, activeBuffer=[%4ux%4u:%4u,%3X],"
2224            " queued-frames=%d, mRefreshPending=%d\n",
2225            mFormat, w0, h0, s0,f0,
2226            mQueuedFrames, mRefreshPending);
2227
2228    if (mSurfaceFlingerConsumer != 0) {
2229        mSurfaceFlingerConsumer->dump(result, "            ");
2230    }
2231}
2232
2233void Layer::dumpFrameStats(String8& result) const {
2234    mFrameTracker.dumpStats(result);
2235}
2236
2237void Layer::clearFrameStats() {
2238    mFrameTracker.clearStats();
2239}
2240
2241void Layer::logFrameStats() {
2242    mFrameTracker.logAndResetStats(mName);
2243}
2244
2245void Layer::getFrameStats(FrameStats* outStats) const {
2246    mFrameTracker.getStats(outStats);
2247}
2248
2249void Layer::getFenceData(String8* outName, uint64_t* outFrameNumber,
2250        bool* outIsGlesComposition, nsecs_t* outPostedTime,
2251        sp<Fence>* outAcquireFence, sp<Fence>* outPrevReleaseFence) const {
2252    *outName = mName;
2253    *outFrameNumber = mSurfaceFlingerConsumer->getFrameNumber();
2254
2255#ifdef USE_HWC2
2256    *outIsGlesComposition = mHwcLayers.count(HWC_DISPLAY_PRIMARY) ?
2257            mHwcLayers.at(HWC_DISPLAY_PRIMARY).compositionType ==
2258            HWC2::Composition::Client : true;
2259#else
2260    *outIsGlesComposition = mIsGlesComposition;
2261#endif
2262    *outPostedTime = mSurfaceFlingerConsumer->getTimestamp();
2263    *outAcquireFence = mSurfaceFlingerConsumer->getCurrentFence();
2264    *outPrevReleaseFence = mSurfaceFlingerConsumer->getPrevReleaseFence();
2265}
2266
2267std::vector<OccupancyTracker::Segment> Layer::getOccupancyHistory(
2268        bool forceFlush) {
2269    std::vector<OccupancyTracker::Segment> history;
2270    status_t result = mSurfaceFlingerConsumer->getOccupancyHistory(forceFlush,
2271            &history);
2272    if (result != NO_ERROR) {
2273        ALOGW("[%s] Failed to obtain occupancy history (%d)", mName.string(),
2274                result);
2275        return {};
2276    }
2277    return history;
2278}
2279
2280bool Layer::getTransformToDisplayInverse() const {
2281    return mSurfaceFlingerConsumer->getTransformToDisplayInverse();
2282}
2283
2284// ---------------------------------------------------------------------------
2285
2286Layer::LayerCleaner::LayerCleaner(const sp<SurfaceFlinger>& flinger,
2287        const sp<Layer>& layer)
2288    : mFlinger(flinger), mLayer(layer) {
2289}
2290
2291Layer::LayerCleaner::~LayerCleaner() {
2292    // destroy client resources
2293    mFlinger->onLayerDestroyed(mLayer);
2294}
2295
2296// ---------------------------------------------------------------------------
2297}; // namespace android
2298
2299#if defined(__gl_h_)
2300#error "don't include gl/gl.h in this file"
2301#endif
2302
2303#if defined(__gl2_h_)
2304#error "don't include gl2/gl2.h in this file"
2305#endif
2306