SurfaceFlinger_hwc1.cpp revision 1971b63aa4d82db37794f19e0eb01feb1826e422 
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 ATRACE_TAG ATRACE_TAG_GRAPHICS
18
19#include <dlfcn.h>
20#include <errno.h>
21#include <inttypes.h>
22#include <math.h>
23#include <stdatomic.h>
24#include <stdint.h>
25#include <sys/types.h>
26
27#include <mutex>
28
29#include <EGL/egl.h>
30
31#include <cutils/properties.h>
32#include <log/log.h>
33
34#include <binder/IPCThreadState.h>
35#include <binder/IServiceManager.h>
36#include <binder/PermissionCache.h>
37
38#include <ui/DisplayInfo.h>
39#include <ui/DisplayStatInfo.h>
40
41#include <gui/BufferQueue.h>
42#include <gui/GuiConfig.h>
43#include <gui/IDisplayEventConnection.h>
44#include <gui/Surface.h>
45#include <gui/GraphicBufferAlloc.h>
46
47#include <ui/GraphicBufferAllocator.h>
48#include <ui/HdrCapabilities.h>
49#include <ui/PixelFormat.h>
50#include <ui/UiConfig.h>
51
52#include <utils/misc.h>
53#include <utils/String8.h>
54#include <utils/String16.h>
55#include <utils/StopWatch.h>
56#include <utils/Timers.h>
57#include <utils/Trace.h>
58
59#include <private/android_filesystem_config.h>
60#include <private/gui/SyncFeatures.h>
61
62#include <set>
63
64#include "Client.h"
65#include "clz.h"
66#include "Colorizer.h"
67#include "DdmConnection.h"
68#include "DisplayDevice.h"
69#include "DispSync.h"
70#include "EventControlThread.h"
71#include "EventThread.h"
72#include "Layer.h"
73#include "LayerVector.h"
74#include "LayerDim.h"
75#include "MonitoredProducer.h"
76#include "SurfaceFlinger.h"
77
78#include "DisplayHardware/FramebufferSurface.h"
79#include "DisplayHardware/HWComposer.h"
80#include "DisplayHardware/VirtualDisplaySurface.h"
81
82#include "Effects/Daltonizer.h"
83
84#include "RenderEngine/RenderEngine.h"
85#include <cutils/compiler.h>
86
87#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
88#include <configstore/Utils.h>
89
90#define DISPLAY_COUNT       1
91
92/*
93 * DEBUG_SCREENSHOTS: set to true to check that screenshots are not all
94 * black pixels.
95 */
96#define DEBUG_SCREENSHOTS   false
97
98EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name);
99
100namespace android {
101// ---------------------------------------------------------------------------
102
103using namespace android::hardware::configstore;
104using namespace android::hardware::configstore::V1_0;
105
106const String16 sHardwareTest("android.permission.HARDWARE_TEST");
107const String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER");
108const String16 sReadFramebuffer("android.permission.READ_FRAME_BUFFER");
109const String16 sDump("android.permission.DUMP");
110
111// ---------------------------------------------------------------------------
112int64_t SurfaceFlinger::vsyncPhaseOffsetNs;
113int64_t SurfaceFlinger::sfVsyncPhaseOffsetNs;
114bool SurfaceFlinger::useContextPriority;
115int64_t SurfaceFlinger::dispSyncPresentTimeOffset;
116bool SurfaceFlinger::useHwcForRgbToYuv;
117uint64_t SurfaceFlinger::maxVirtualDisplaySize;
118bool SurfaceFlinger::hasSyncFramework;
119int64_t SurfaceFlinger::maxFrameBufferAcquiredBuffers;
120
121SurfaceFlinger::SurfaceFlinger()
122    :   BnSurfaceComposer(),
123        mTransactionFlags(0),
124        mTransactionPending(false),
125        mAnimTransactionPending(false),
126        mLayersRemoved(false),
127        mLayersAdded(false),
128        mRepaintEverything(0),
129        mRenderEngine(NULL),
130        mBootTime(systemTime()),
131        mVisibleRegionsDirty(false),
132        mHwWorkListDirty(false),
133        mAnimCompositionPending(false),
134        mDebugRegion(0),
135        mDebugDDMS(0),
136        mDebugDisableHWC(0),
137        mDebugDisableTransformHint(0),
138        mDebugInSwapBuffers(0),
139        mLastSwapBufferTime(0),
140        mDebugInTransaction(0),
141        mLastTransactionTime(0),
142        mBootFinished(false),
143        mForceFullDamage(false),
144        mInterceptor(this),
145        mPrimaryDispSync("PrimaryDispSync"),
146        mPrimaryHWVsyncEnabled(false),
147        mHWVsyncAvailable(false),
148        mDaltonize(false),
149        mHasColorMatrix(false),
150        mHasPoweredOff(false),
151        mFrameBuckets(),
152        mTotalTime(0),
153        mLastSwapTime(0),
154        mNumLayers(0)
155{
156    ALOGI("SurfaceFlinger is starting");
157
158    vsyncPhaseOffsetNs = getInt64< ISurfaceFlingerConfigs,
159            &ISurfaceFlingerConfigs::vsyncEventPhaseOffsetNs>(1000000);
160
161    sfVsyncPhaseOffsetNs = getInt64< ISurfaceFlingerConfigs,
162            &ISurfaceFlingerConfigs::vsyncSfEventPhaseOffsetNs>(1000000);
163
164    maxVirtualDisplaySize = getUInt64<ISurfaceFlingerConfigs,
165            &ISurfaceFlingerConfigs::maxVirtualDisplaySize>(0);
166
167    hasSyncFramework = getBool< ISurfaceFlingerConfigs,
168            &ISurfaceFlingerConfigs::hasSyncFramework>(true);
169
170    useContextPriority = getBool< ISurfaceFlingerConfigs,
171            &ISurfaceFlingerConfigs::useContextPriority>(false);
172
173    dispSyncPresentTimeOffset = getInt64< ISurfaceFlingerConfigs,
174            &ISurfaceFlingerConfigs::presentTimeOffsetFromVSyncNs>(0);
175
176    useHwcForRgbToYuv = getBool< ISurfaceFlingerConfigs,
177            &ISurfaceFlingerConfigs::useHwcForRGBtoYUV>(false);
178
179    maxFrameBufferAcquiredBuffers = getInt64< ISurfaceFlingerConfigs,
180            &ISurfaceFlingerConfigs::maxFrameBufferAcquiredBuffers>(2);
181
182    char value[PROPERTY_VALUE_MAX];
183
184    property_get("ro.bq.gpu_to_cpu_unsupported", value, "0");
185    mGpuToCpuSupported = !atoi(value);
186
187    property_get("debug.sf.showupdates", value, "0");
188    mDebugRegion = atoi(value);
189
190    property_get("debug.sf.ddms", value, "0");
191    mDebugDDMS = atoi(value);
192    if (mDebugDDMS) {
193        if (!startDdmConnection()) {
194            // start failed, and DDMS debugging not enabled
195            mDebugDDMS = 0;
196        }
197    }
198    ALOGI_IF(mDebugRegion, "showupdates enabled");
199    ALOGI_IF(mDebugDDMS, "DDMS debugging enabled");
200
201    property_get("debug.sf.enable_hwc_vds", value, "0");
202    mUseHwcVirtualDisplays = atoi(value);
203    ALOGI_IF(!mUseHwcVirtualDisplays, "Enabling HWC virtual displays");
204
205    property_get("ro.sf.disable_triple_buffer", value, "1");
206    mLayerTripleBufferingDisabled = atoi(value);
207    ALOGI_IF(mLayerTripleBufferingDisabled, "Disabling Triple Buffering");
208}
209
210void SurfaceFlinger::onFirstRef()
211{
212    mEventQueue.init(this);
213}
214
215SurfaceFlinger::~SurfaceFlinger()
216{
217    EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
218    eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
219    eglTerminate(display);
220}
221
222void SurfaceFlinger::binderDied(const wp<IBinder>& /* who */)
223{
224    // the window manager died on us. prepare its eulogy.
225
226    // restore initial conditions (default device unblank, etc)
227    initializeDisplays();
228
229    // restart the boot-animation
230    startBootAnim();
231}
232
233static sp<ISurfaceComposerClient> initClient(const sp<Client>& client) {
234    status_t err = client->initCheck();
235    if (err == NO_ERROR) {
236        return client;
237    }
238    return nullptr;
239}
240
241sp<ISurfaceComposerClient> SurfaceFlinger::createConnection() {
242    return initClient(new Client(this));
243}
244
245sp<ISurfaceComposerClient> SurfaceFlinger::createScopedConnection(
246        const sp<IGraphicBufferProducer>& gbp) {
247    if (authenticateSurfaceTexture(gbp) == false) {
248        return nullptr;
249    }
250    const auto& layer = (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
251    if (layer == nullptr) {
252        return nullptr;
253    }
254
255   return initClient(new Client(this, layer));
256}
257
258sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName,
259        bool secure)
260{
261    class DisplayToken : public BBinder {
262        sp<SurfaceFlinger> flinger;
263        virtual ~DisplayToken() {
264             // no more references, this display must be terminated
265             Mutex::Autolock _l(flinger->mStateLock);
266             flinger->mCurrentState.displays.removeItem(this);
267             flinger->setTransactionFlags(eDisplayTransactionNeeded);
268         }
269     public:
270        explicit DisplayToken(const sp<SurfaceFlinger>& flinger)
271            : flinger(flinger) {
272        }
273    };
274
275    sp<BBinder> token = new DisplayToken(this);
276
277    Mutex::Autolock _l(mStateLock);
278    DisplayDeviceState info(DisplayDevice::DISPLAY_VIRTUAL, secure);
279    info.displayName = displayName;
280    mCurrentState.displays.add(token, info);
281    mInterceptor.saveDisplayCreation(info);
282    return token;
283}
284
285void SurfaceFlinger::destroyDisplay(const sp<IBinder>& display) {
286    Mutex::Autolock _l(mStateLock);
287
288    ssize_t idx = mCurrentState.displays.indexOfKey(display);
289    if (idx < 0) {
290        ALOGW("destroyDisplay: invalid display token");
291        return;
292    }
293
294    const DisplayDeviceState& info(mCurrentState.displays.valueAt(idx));
295    if (!info.isVirtualDisplay()) {
296        ALOGE("destroyDisplay called for non-virtual display");
297        return;
298    }
299    mInterceptor.saveDisplayDeletion(info.displayId);
300    mCurrentState.displays.removeItemsAt(idx);
301    setTransactionFlags(eDisplayTransactionNeeded);
302}
303
304void SurfaceFlinger::createBuiltinDisplayLocked(DisplayDevice::DisplayType type) {
305    ALOGW_IF(mBuiltinDisplays[type],
306            "Overwriting display token for display type %d", type);
307    mBuiltinDisplays[type] = new BBinder();
308    // All non-virtual displays are currently considered secure.
309    DisplayDeviceState info(type, true);
310    mCurrentState.displays.add(mBuiltinDisplays[type], info);
311    mInterceptor.saveDisplayCreation(info);
312}
313
314sp<IBinder> SurfaceFlinger::getBuiltInDisplay(int32_t id) {
315    if (uint32_t(id) >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
316        ALOGE("getDefaultDisplay: id=%d is not a valid default display id", id);
317        return NULL;
318    }
319    return mBuiltinDisplays[id];
320}
321
322sp<IGraphicBufferAlloc> SurfaceFlinger::createGraphicBufferAlloc()
323{
324    sp<GraphicBufferAlloc> gba(new GraphicBufferAlloc());
325    return gba;
326}
327
328void SurfaceFlinger::bootFinished()
329{
330    if (mStartBootAnimThread->join() != NO_ERROR) {
331        ALOGE("Join StartBootAnimThread failed!");
332    }
333    const nsecs_t now = systemTime();
334    const nsecs_t duration = now - mBootTime;
335    ALOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) );
336    mBootFinished = true;
337
338    // wait patiently for the window manager death
339    const String16 name("window");
340    sp<IBinder> window(defaultServiceManager()->getService(name));
341    if (window != 0) {
342        window->linkToDeath(static_cast<IBinder::DeathRecipient*>(this));
343    }
344
345    // stop boot animation
346    // formerly we would just kill the process, but we now ask it to exit so it
347    // can choose where to stop the animation.
348    property_set("service.bootanim.exit", "1");
349
350    const int LOGTAG_SF_STOP_BOOTANIM = 60110;
351    LOG_EVENT_LONG(LOGTAG_SF_STOP_BOOTANIM,
352                   ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
353}
354
355void SurfaceFlinger::deleteTextureAsync(uint32_t texture) {
356    class MessageDestroyGLTexture : public MessageBase {
357        RenderEngine& engine;
358        uint32_t texture;
359    public:
360        MessageDestroyGLTexture(RenderEngine& engine, uint32_t texture)
361            : engine(engine), texture(texture) {
362        }
363        virtual bool handler() {
364            engine.deleteTextures(1, &texture);
365            return true;
366        }
367    };
368    postMessageAsync(new MessageDestroyGLTexture(getRenderEngine(), texture));
369}
370
371class DispSyncSource : public VSyncSource, private DispSync::Callback {
372public:
373    DispSyncSource(DispSync* dispSync, nsecs_t phaseOffset, bool traceVsync,
374        const char* name) :
375            mName(name),
376            mValue(0),
377            mTraceVsync(traceVsync),
378            mVsyncOnLabel(String8::format("VsyncOn-%s", name)),
379            mVsyncEventLabel(String8::format("VSYNC-%s", name)),
380            mDispSync(dispSync),
381            mCallbackMutex(),
382            mCallback(),
383            mVsyncMutex(),
384            mPhaseOffset(phaseOffset),
385            mEnabled(false) {}
386
387    virtual ~DispSyncSource() {}
388
389    virtual void setVSyncEnabled(bool enable) {
390        Mutex::Autolock lock(mVsyncMutex);
391        if (enable) {
392            status_t err = mDispSync->addEventListener(mName, mPhaseOffset,
393                    static_cast<DispSync::Callback*>(this));
394            if (err != NO_ERROR) {
395                ALOGE("error registering vsync callback: %s (%d)",
396                        strerror(-err), err);
397            }
398            //ATRACE_INT(mVsyncOnLabel.string(), 1);
399        } else {
400            status_t err = mDispSync->removeEventListener(
401                    static_cast<DispSync::Callback*>(this));
402            if (err != NO_ERROR) {
403                ALOGE("error unregistering vsync callback: %s (%d)",
404                        strerror(-err), err);
405            }
406            //ATRACE_INT(mVsyncOnLabel.string(), 0);
407        }
408        mEnabled = enable;
409    }
410
411    virtual void setCallback(const sp<VSyncSource::Callback>& callback) {
412        Mutex::Autolock lock(mCallbackMutex);
413        mCallback = callback;
414    }
415
416    virtual void setPhaseOffset(nsecs_t phaseOffset) {
417        Mutex::Autolock lock(mVsyncMutex);
418
419        // Normalize phaseOffset to [0, period)
420        auto period = mDispSync->getPeriod();
421        phaseOffset %= period;
422        if (phaseOffset < 0) {
423            // If we're here, then phaseOffset is in (-period, 0). After this
424            // operation, it will be in (0, period)
425            phaseOffset += period;
426        }
427        mPhaseOffset = phaseOffset;
428
429        // If we're not enabled, we don't need to mess with the listeners
430        if (!mEnabled) {
431            return;
432        }
433
434        // Remove the listener with the old offset
435        status_t err = mDispSync->removeEventListener(
436                static_cast<DispSync::Callback*>(this));
437        if (err != NO_ERROR) {
438            ALOGE("error unregistering vsync callback: %s (%d)",
439                    strerror(-err), err);
440        }
441
442        // Add a listener with the new offset
443        err = mDispSync->addEventListener(mName, mPhaseOffset,
444                static_cast<DispSync::Callback*>(this));
445        if (err != NO_ERROR) {
446            ALOGE("error registering vsync callback: %s (%d)",
447                    strerror(-err), err);
448        }
449    }
450
451private:
452    virtual void onDispSyncEvent(nsecs_t when) {
453        sp<VSyncSource::Callback> callback;
454        {
455            Mutex::Autolock lock(mCallbackMutex);
456            callback = mCallback;
457
458            if (mTraceVsync) {
459                mValue = (mValue + 1) % 2;
460                ATRACE_INT(mVsyncEventLabel.string(), mValue);
461            }
462        }
463
464        if (callback != NULL) {
465            callback->onVSyncEvent(when);
466        }
467    }
468
469    const char* const mName;
470
471    int mValue;
472
473    const bool mTraceVsync;
474    const String8 mVsyncOnLabel;
475    const String8 mVsyncEventLabel;
476
477    DispSync* mDispSync;
478
479    Mutex mCallbackMutex; // Protects the following
480    sp<VSyncSource::Callback> mCallback;
481
482    Mutex mVsyncMutex; // Protects the following
483    nsecs_t mPhaseOffset;
484    bool mEnabled;
485};
486
487class InjectVSyncSource : public VSyncSource {
488public:
489    InjectVSyncSource() {}
490
491    virtual ~InjectVSyncSource() {}
492
493    virtual void setCallback(const sp<VSyncSource::Callback>& callback) {
494        std::lock_guard<std::mutex> lock(mCallbackMutex);
495        mCallback = callback;
496    }
497
498    virtual void onInjectSyncEvent(nsecs_t when) {
499        std::lock_guard<std::mutex> lock(mCallbackMutex);
500        mCallback->onVSyncEvent(when);
501    }
502
503    virtual void setVSyncEnabled(bool) {}
504    virtual void setPhaseOffset(nsecs_t) {}
505
506private:
507    std::mutex mCallbackMutex; // Protects the following
508    sp<VSyncSource::Callback> mCallback;
509};
510
511void SurfaceFlinger::init() {
512    ALOGI(  "SurfaceFlinger's main thread ready to run. "
513            "Initializing graphics H/W...");
514
515    Mutex::Autolock _l(mStateLock);
516
517    // initialize EGL for the default display
518    mEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
519    eglInitialize(mEGLDisplay, NULL, NULL);
520
521    // start the EventThread
522    sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync,
523            vsyncPhaseOffsetNs, true, "app");
524    mEventThread = new EventThread(vsyncSrc, *this, false);
525    sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,
526            sfVsyncPhaseOffsetNs, true, "sf");
527    mSFEventThread = new EventThread(sfVsyncSrc, *this, true);
528    mEventQueue.setEventThread(mSFEventThread);
529
530    // set SFEventThread to SCHED_FIFO to minimize jitter
531    struct sched_param param = {0};
532    param.sched_priority = 2;
533    if (sched_setscheduler(mSFEventThread->getTid(), SCHED_FIFO, &param) != 0) {
534        ALOGE("Couldn't set SCHED_FIFO for SFEventThread");
535    }
536
537
538    // Initialize the H/W composer object.  There may or may not be an
539    // actual hardware composer underneath.
540    mHwc = new HWComposer(this,
541            *static_cast<HWComposer::EventHandler *>(this));
542
543    // get a RenderEngine for the given display / config (can't fail)
544    mRenderEngine = RenderEngine::create(mEGLDisplay, mHwc->getVisualID());
545
546    // retrieve the EGL context that was selected/created
547    mEGLContext = mRenderEngine->getEGLContext();
548
549    LOG_ALWAYS_FATAL_IF(mEGLContext == EGL_NO_CONTEXT,
550            "couldn't create EGLContext");
551
552    // initialize our non-virtual displays
553    for (size_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {
554        DisplayDevice::DisplayType type((DisplayDevice::DisplayType)i);
555        // set-up the displays that are already connected
556        if (mHwc->isConnected(i) || type==DisplayDevice::DISPLAY_PRIMARY) {
557            // All non-virtual displays are currently considered secure.
558            bool isSecure = true;
559            createBuiltinDisplayLocked(type);
560            wp<IBinder> token = mBuiltinDisplays[i];
561
562            sp<IGraphicBufferProducer> producer;
563            sp<IGraphicBufferConsumer> consumer;
564            BufferQueue::createBufferQueue(&producer, &consumer,
565                    new GraphicBufferAlloc());
566
567            sp<FramebufferSurface> fbs = new FramebufferSurface(*mHwc, i,
568                    consumer);
569            int32_t hwcId = allocateHwcDisplayId(type);
570            sp<DisplayDevice> hw = new DisplayDevice(this,
571                    type, hwcId, mHwc->getFormat(hwcId), isSecure, token,
572                    fbs, producer,
573                    mRenderEngine->getEGLConfig());
574            if (i > DisplayDevice::DISPLAY_PRIMARY) {
575                // FIXME: currently we don't get blank/unblank requests
576                // for displays other than the main display, so we always
577                // assume a connected display is unblanked.
578                ALOGD("marking display %zu as acquired/unblanked", i);
579                hw->setPowerMode(HWC_POWER_MODE_NORMAL);
580            }
581            mDisplays.add(token, hw);
582        }
583    }
584
585    // make the GLContext current so that we can create textures when creating Layers
586    // (which may happens before we render something)
587    getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
588
589    mEventControlThread = new EventControlThread(this);
590    mEventControlThread->run("EventControl", PRIORITY_URGENT_DISPLAY);
591
592    // set a fake vsync period if there is no HWComposer
593    if (mHwc->initCheck() != NO_ERROR) {
594        mPrimaryDispSync.setPeriod(16666667);
595    }
596
597    // initialize our drawing state
598    mDrawingState = mCurrentState;
599
600    // set initial conditions (e.g. unblank default device)
601    initializeDisplays();
602
603    mRenderEngine->primeCache();
604
605    mStartBootAnimThread = new StartBootAnimThread();
606    if (mStartBootAnimThread->Start() != NO_ERROR) {
607        ALOGE("Run StartBootAnimThread failed!");
608    }
609
610    ALOGV("Done initializing");
611}
612
613int32_t SurfaceFlinger::allocateHwcDisplayId(DisplayDevice::DisplayType type) {
614    return (uint32_t(type) < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) ?
615            type : mHwc->allocateDisplayId();
616}
617
618void SurfaceFlinger::startBootAnim() {
619    // Start boot animation service by setting a property mailbox
620    // if property setting thread is already running, Start() will be just a NOP
621    mStartBootAnimThread->Start();
622    // Wait until property was set
623    if (mStartBootAnimThread->join() != NO_ERROR) {
624        ALOGE("Join StartBootAnimThread failed!");
625    }
626}
627
628size_t SurfaceFlinger::getMaxTextureSize() const {
629    return mRenderEngine->getMaxTextureSize();
630}
631
632size_t SurfaceFlinger::getMaxViewportDims() const {
633    return mRenderEngine->getMaxViewportDims();
634}
635
636// ----------------------------------------------------------------------------
637
638bool SurfaceFlinger::authenticateSurfaceTexture(
639        const sp<IGraphicBufferProducer>& bufferProducer) const {
640    Mutex::Autolock _l(mStateLock);
641    return authenticateSurfaceTextureLocked(bufferProducer);
642}
643
644bool SurfaceFlinger::authenticateSurfaceTextureLocked(
645        const sp<IGraphicBufferProducer>& bufferProducer) const {
646    sp<IBinder> surfaceTextureBinder(IInterface::asBinder(bufferProducer));
647    return mGraphicBufferProducerList.indexOf(surfaceTextureBinder) >= 0;
648}
649
650status_t SurfaceFlinger::getDisplayConfigs(const sp<IBinder>& display,
651        Vector<DisplayInfo>* configs) {
652    if ((configs == NULL) || (display.get() == NULL)) {
653        return BAD_VALUE;
654    }
655
656    int32_t type = getDisplayType(display);
657    if (type < 0) return type;
658
659    // TODO: Not sure if display density should handled by SF any longer
660    class Density {
661        static int getDensityFromProperty(char const* propName) {
662            char property[PROPERTY_VALUE_MAX];
663            int density = 0;
664            if (property_get(propName, property, NULL) > 0) {
665                density = atoi(property);
666            }
667            return density;
668        }
669    public:
670        static int getEmuDensity() {
671            return getDensityFromProperty("qemu.sf.lcd_density"); }
672        static int getBuildDensity()  {
673            return getDensityFromProperty("ro.sf.lcd_density"); }
674    };
675
676    configs->clear();
677
678    const Vector<HWComposer::DisplayConfig>& hwConfigs =
679            getHwComposer().getConfigs(type);
680    for (size_t c = 0; c < hwConfigs.size(); ++c) {
681        const HWComposer::DisplayConfig& hwConfig = hwConfigs[c];
682        DisplayInfo info = DisplayInfo();
683
684        float xdpi = hwConfig.xdpi;
685        float ydpi = hwConfig.ydpi;
686
687        if (type == DisplayDevice::DISPLAY_PRIMARY) {
688            // The density of the device is provided by a build property
689            float density = Density::getBuildDensity() / 160.0f;
690            if (density == 0) {
691                // the build doesn't provide a density -- this is wrong!
692                // use xdpi instead
693                ALOGE("ro.sf.lcd_density must be defined as a build property");
694                density = xdpi / 160.0f;
695            }
696            if (Density::getEmuDensity()) {
697                // if "qemu.sf.lcd_density" is specified, it overrides everything
698                xdpi = ydpi = density = Density::getEmuDensity();
699                density /= 160.0f;
700            }
701            info.density = density;
702
703            // TODO: this needs to go away (currently needed only by webkit)
704            sp<const DisplayDevice> hw(getDefaultDisplayDevice());
705            info.orientation = hw->getOrientation();
706        } else {
707            // TODO: where should this value come from?
708            static const int TV_DENSITY = 213;
709            info.density = TV_DENSITY / 160.0f;
710            info.orientation = 0;
711        }
712
713        info.w = hwConfig.width;
714        info.h = hwConfig.height;
715        info.xdpi = xdpi;
716        info.ydpi = ydpi;
717        info.fps = float(1e9 / hwConfig.refresh);
718        info.appVsyncOffset = vsyncPhaseOffsetNs;
719
720        // This is how far in advance a buffer must be queued for
721        // presentation at a given time.  If you want a buffer to appear
722        // on the screen at time N, you must submit the buffer before
723        // (N - presentationDeadline).
724        //
725        // Normally it's one full refresh period (to give SF a chance to
726        // latch the buffer), but this can be reduced by configuring a
727        // DispSync offset.  Any additional delays introduced by the hardware
728        // composer or panel must be accounted for here.
729        //
730        // We add an additional 1ms to allow for processing time and
731        // differences between the ideal and actual refresh rate.
732        info.presentationDeadline =
733                hwConfig.refresh - sfVsyncPhaseOffsetNs + 1000000;
734
735        // All non-virtual displays are currently considered secure.
736        info.secure = true;
737
738        configs->push_back(info);
739    }
740
741    return NO_ERROR;
742}
743
744status_t SurfaceFlinger::getDisplayStats(const sp<IBinder>& /* display */,
745        DisplayStatInfo* stats) {
746    if (stats == NULL) {
747        return BAD_VALUE;
748    }
749
750    // FIXME for now we always return stats for the primary display
751    memset(stats, 0, sizeof(*stats));
752    stats->vsyncTime   = mPrimaryDispSync.computeNextRefresh(0);
753    stats->vsyncPeriod = mPrimaryDispSync.getPeriod();
754    return NO_ERROR;
755}
756
757int SurfaceFlinger::getActiveConfig(const sp<IBinder>& display) {
758    sp<DisplayDevice> device(getDisplayDevice(display));
759    if (device != NULL) {
760        return device->getActiveConfig();
761    }
762    return BAD_VALUE;
763}
764
765void SurfaceFlinger::setActiveConfigInternal(const sp<DisplayDevice>& hw, int mode) {
766    ALOGD("Set active config mode=%d, type=%d flinger=%p", mode, hw->getDisplayType(),
767          this);
768    int32_t type = hw->getDisplayType();
769    int currentMode = hw->getActiveConfig();
770
771    if (mode == currentMode) {
772        ALOGD("Screen type=%d is already mode=%d", hw->getDisplayType(), mode);
773        return;
774    }
775
776    if (type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
777        ALOGW("Trying to set config for virtual display");
778        return;
779    }
780
781    hw->setActiveConfig(mode);
782    getHwComposer().setActiveConfig(type, mode);
783}
784
785status_t SurfaceFlinger::setActiveConfig(const sp<IBinder>& display, int mode) {
786    class MessageSetActiveConfig: public MessageBase {
787        SurfaceFlinger& mFlinger;
788        sp<IBinder> mDisplay;
789        int mMode;
790    public:
791        MessageSetActiveConfig(SurfaceFlinger& flinger, const sp<IBinder>& disp,
792                               int mode) :
793            mFlinger(flinger), mDisplay(disp) { mMode = mode; }
794        virtual bool handler() {
795            Vector<DisplayInfo> configs;
796            mFlinger.getDisplayConfigs(mDisplay, &configs);
797            if (mMode < 0 || mMode >= static_cast<int>(configs.size())) {
798                ALOGE("Attempt to set active config = %d for display with %zu configs",
799                        mMode, configs.size());
800            }
801            sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay));
802            if (hw == NULL) {
803                ALOGE("Attempt to set active config = %d for null display %p",
804                        mMode, mDisplay.get());
805            } else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) {
806                ALOGW("Attempt to set active config = %d for virtual display",
807                        mMode);
808            } else {
809                mFlinger.setActiveConfigInternal(hw, mMode);
810            }
811            return true;
812        }
813    };
814    sp<MessageBase> msg = new MessageSetActiveConfig(*this, display, mode);
815    postMessageSync(msg);
816    return NO_ERROR;
817}
818
819status_t SurfaceFlinger::getDisplayColorModes(const sp<IBinder>& display,
820        Vector<android_color_mode_t>* outColorModes) {
821    if (outColorModes == nullptr || display.get() == nullptr) {
822        return BAD_VALUE;
823    }
824
825    int32_t type = getDisplayType(display);
826    if (type < 0) return type;
827
828    std::set<android_color_mode_t> colorModes;
829    for (const HWComposer::DisplayConfig& hwConfig : getHwComposer().getConfigs(type)) {
830        colorModes.insert(hwConfig.colorMode);
831    }
832
833    outColorModes->clear();
834    std::copy(colorModes.cbegin(), colorModes.cend(), std::back_inserter(*outColorModes));
835
836    return NO_ERROR;
837}
838
839android_color_mode_t SurfaceFlinger::getActiveColorMode(const sp<IBinder>& display) {
840    if (display.get() == nullptr) return static_cast<android_color_mode_t>(BAD_VALUE);
841
842    int32_t type = getDisplayType(display);
843    if (type < 0) return static_cast<android_color_mode_t>(type);
844
845    return getHwComposer().getColorMode(type);
846}
847
848status_t SurfaceFlinger::setActiveColorMode(const sp<IBinder>& display,
849        android_color_mode_t colorMode) {
850    if (display.get() == nullptr || colorMode < 0) {
851        return BAD_VALUE;
852    }
853
854    int32_t type = getDisplayType(display);
855    if (type < 0) return type;
856    const Vector<HWComposer::DisplayConfig>& hwConfigs = getHwComposer().getConfigs(type);
857    HWComposer::DisplayConfig desiredConfig = hwConfigs[getHwComposer().getCurrentConfig(type)];
858    desiredConfig.colorMode = colorMode;
859    for (size_t c = 0; c < hwConfigs.size(); ++c) {
860        const HWComposer::DisplayConfig config = hwConfigs[c];
861        if (config == desiredConfig) {
862            return setActiveConfig(display, c);
863        }
864    }
865    return BAD_VALUE;
866}
867
868status_t SurfaceFlinger::clearAnimationFrameStats() {
869    Mutex::Autolock _l(mStateLock);
870    mAnimFrameTracker.clearStats();
871    return NO_ERROR;
872}
873
874status_t SurfaceFlinger::getAnimationFrameStats(FrameStats* outStats) const {
875    Mutex::Autolock _l(mStateLock);
876    mAnimFrameTracker.getStats(outStats);
877    return NO_ERROR;
878}
879
880status_t SurfaceFlinger::getHdrCapabilities(const sp<IBinder>& /*display*/,
881        HdrCapabilities* outCapabilities) const {
882    // HWC1 does not provide HDR capabilities
883    *outCapabilities = HdrCapabilities();
884    return NO_ERROR;
885}
886
887status_t SurfaceFlinger::enableVSyncInjections(bool enable) {
888    if (enable == mInjectVSyncs) {
889        return NO_ERROR;
890    }
891
892    if (enable) {
893        mInjectVSyncs = enable;
894        ALOGV("VSync Injections enabled");
895        if (mVSyncInjector.get() == nullptr) {
896            mVSyncInjector = new InjectVSyncSource();
897            mInjectorEventThread = new EventThread(mVSyncInjector, *this, false);
898        }
899        mEventQueue.setEventThread(mInjectorEventThread);
900    } else {
901        mInjectVSyncs = enable;
902        ALOGV("VSync Injections disabled");
903        mEventQueue.setEventThread(mSFEventThread);
904        mVSyncInjector.clear();
905    }
906    return NO_ERROR;
907}
908
909status_t SurfaceFlinger::injectVSync(nsecs_t when) {
910    if (!mInjectVSyncs) {
911        ALOGE("VSync Injections not enabled");
912        return BAD_VALUE;
913    }
914    if (mInjectVSyncs && mInjectorEventThread.get() != nullptr) {
915        ALOGV("Injecting VSync inside SurfaceFlinger");
916        mVSyncInjector->onInjectSyncEvent(when);
917    }
918    return NO_ERROR;
919}
920
921// ----------------------------------------------------------------------------
922
923sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection() {
924    return mEventThread->createEventConnection();
925}
926
927// ----------------------------------------------------------------------------
928
929void SurfaceFlinger::waitForEvent() {
930    mEventQueue.waitMessage();
931}
932
933void SurfaceFlinger::signalTransaction() {
934    mEventQueue.invalidate();
935}
936
937void SurfaceFlinger::signalLayerUpdate() {
938    mEventQueue.invalidate();
939}
940
941void SurfaceFlinger::signalRefresh() {
942    mEventQueue.refresh();
943}
944
945status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg,
946        nsecs_t reltime, uint32_t /* flags */) {
947    return mEventQueue.postMessage(msg, reltime);
948}
949
950status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,
951        nsecs_t reltime, uint32_t /* flags */) {
952    status_t res = mEventQueue.postMessage(msg, reltime);
953    if (res == NO_ERROR) {
954        msg->wait();
955    }
956    return res;
957}
958
959void SurfaceFlinger::run() {
960    do {
961        waitForEvent();
962    } while (true);
963}
964
965void SurfaceFlinger::enableHardwareVsync() {
966    Mutex::Autolock _l(mHWVsyncLock);
967    if (!mPrimaryHWVsyncEnabled && mHWVsyncAvailable) {
968        mPrimaryDispSync.beginResync();
969        //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, true);
970        mEventControlThread->setVsyncEnabled(true);
971        mPrimaryHWVsyncEnabled = true;
972    }
973}
974
975void SurfaceFlinger::resyncToHardwareVsync(bool makeAvailable) {
976    Mutex::Autolock _l(mHWVsyncLock);
977
978    if (makeAvailable) {
979        mHWVsyncAvailable = true;
980    } else if (!mHWVsyncAvailable) {
981        // Hardware vsync is not currently available, so abort the resync
982        // attempt for now
983        return;
984    }
985
986    const nsecs_t period =
987            getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
988
989    mPrimaryDispSync.reset();
990    mPrimaryDispSync.setPeriod(period);
991
992    if (!mPrimaryHWVsyncEnabled) {
993        mPrimaryDispSync.beginResync();
994        //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, true);
995        mEventControlThread->setVsyncEnabled(true);
996        mPrimaryHWVsyncEnabled = true;
997    }
998}
999
1000void SurfaceFlinger::disableHardwareVsync(bool makeUnavailable) {
1001    Mutex::Autolock _l(mHWVsyncLock);
1002    if (mPrimaryHWVsyncEnabled) {
1003        //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, false);
1004        mEventControlThread->setVsyncEnabled(false);
1005        mPrimaryDispSync.endResync();
1006        mPrimaryHWVsyncEnabled = false;
1007    }
1008    if (makeUnavailable) {
1009        mHWVsyncAvailable = false;
1010    }
1011}
1012
1013void SurfaceFlinger::resyncWithRateLimit() {
1014    static constexpr nsecs_t kIgnoreDelay = ms2ns(500);
1015    if (systemTime() - mLastSwapTime > kIgnoreDelay) {
1016        resyncToHardwareVsync(false);
1017    }
1018}
1019
1020void SurfaceFlinger::onVSyncReceived(HWComposer* /*composer*/, int type,
1021                                     nsecs_t timestamp) {
1022    bool needsHwVsync = false;
1023
1024    { // Scope for the lock
1025        Mutex::Autolock _l(mHWVsyncLock);
1026        if (type == 0 && mPrimaryHWVsyncEnabled) {
1027            needsHwVsync = mPrimaryDispSync.addResyncSample(timestamp);
1028        }
1029    }
1030
1031    if (needsHwVsync) {
1032        enableHardwareVsync();
1033    } else {
1034        disableHardwareVsync(false);
1035    }
1036}
1037
1038void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) {
1039    std::lock_guard<std::mutex> lock(mCompositorTimingLock);
1040    *compositorTiming = mCompositorTiming;
1041}
1042
1043void SurfaceFlinger::onHotplugReceived(int type, bool connected) {
1044    if (mEventThread == NULL) {
1045        // This is a temporary workaround for b/7145521.  A non-null pointer
1046        // does not mean EventThread has finished initializing, so this
1047        // is not a correct fix.
1048        ALOGW("WARNING: EventThread not started, ignoring hotplug");
1049        return;
1050    }
1051
1052    if (uint32_t(type) < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
1053        Mutex::Autolock _l(mStateLock);
1054        if (connected) {
1055            createBuiltinDisplayLocked((DisplayDevice::DisplayType)type);
1056        } else {
1057            mCurrentState.displays.removeItem(mBuiltinDisplays[type]);
1058            mBuiltinDisplays[type].clear();
1059        }
1060        setTransactionFlags(eDisplayTransactionNeeded);
1061
1062        // Defer EventThread notification until SF has updated mDisplays.
1063    }
1064}
1065
1066void SurfaceFlinger::onInvalidateReceived(HWComposer* /*composer*/) {
1067    repaintEverything();
1068}
1069
1070void SurfaceFlinger::eventControl(int disp, int event, int enabled) {
1071    ATRACE_CALL();
1072    getHwComposer().eventControl(disp, event, enabled);
1073}
1074
1075void SurfaceFlinger::onMessageReceived(int32_t what) {
1076    ATRACE_CALL();
1077    switch (what) {
1078        case MessageQueue::INVALIDATE: {
1079            bool refreshNeeded = handleMessageTransaction();
1080            refreshNeeded |= handleMessageInvalidate();
1081            refreshNeeded |= mRepaintEverything;
1082            if (refreshNeeded) {
1083                // Signal a refresh if a transaction modified the window state,
1084                // a new buffer was latched, or if HWC has requested a full
1085                // repaint
1086                signalRefresh();
1087            }
1088            break;
1089        }
1090        case MessageQueue::REFRESH: {
1091            handleMessageRefresh();
1092            break;
1093        }
1094    }
1095}
1096
1097bool SurfaceFlinger::handleMessageTransaction() {
1098    uint32_t transactionFlags = peekTransactionFlags();
1099    if (transactionFlags) {
1100        handleTransaction(transactionFlags);
1101        return true;
1102    }
1103    return false;
1104}
1105
1106bool SurfaceFlinger::handleMessageInvalidate() {
1107    ATRACE_CALL();
1108    return handlePageFlip();
1109}
1110
1111void SurfaceFlinger::handleMessageRefresh() {
1112    ATRACE_CALL();
1113
1114    nsecs_t refreshStartTime = systemTime(SYSTEM_TIME_MONOTONIC);
1115
1116    preComposition(refreshStartTime);
1117    rebuildLayerStacks();
1118    setUpHWComposer();
1119    doDebugFlashRegions();
1120    doComposition();
1121    postComposition(refreshStartTime);
1122}
1123
1124void SurfaceFlinger::doDebugFlashRegions()
1125{
1126    // is debugging enabled
1127    if (CC_LIKELY(!mDebugRegion))
1128        return;
1129
1130    const bool repaintEverything = mRepaintEverything;
1131    for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1132        const sp<DisplayDevice>& hw(mDisplays[dpy]);
1133        if (hw->isDisplayOn()) {
1134            // transform the dirty region into this screen's coordinate space
1135            const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));
1136            if (!dirtyRegion.isEmpty()) {
1137                // redraw the whole screen
1138                doComposeSurfaces(hw, Region(hw->bounds()));
1139
1140                // and draw the dirty region
1141                const int32_t height = hw->getHeight();
1142                RenderEngine& engine(getRenderEngine());
1143                engine.fillRegionWithColor(dirtyRegion, height, 1, 0, 1, 1);
1144
1145                hw->compositionComplete();
1146                hw->swapBuffers(getHwComposer());
1147            }
1148        }
1149    }
1150
1151    postFramebuffer();
1152
1153    if (mDebugRegion > 1) {
1154        usleep(mDebugRegion * 1000);
1155    }
1156
1157    HWComposer& hwc(getHwComposer());
1158    if (hwc.initCheck() == NO_ERROR) {
1159        status_t err = hwc.prepare();
1160        ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err));
1161    }
1162}
1163
1164void SurfaceFlinger::preComposition(nsecs_t refreshStartTime)
1165{
1166    bool needExtraInvalidate = false;
1167    mDrawingState.traverseInZOrder([&](Layer* layer) {
1168        if (layer->onPreComposition(refreshStartTime)) {
1169            needExtraInvalidate = true;
1170        }
1171    });
1172
1173    if (needExtraInvalidate) {
1174        signalLayerUpdate();
1175    }
1176}
1177
1178void SurfaceFlinger::updateCompositorTiming(
1179        nsecs_t vsyncPhase, nsecs_t vsyncInterval, nsecs_t compositeTime,
1180        std::shared_ptr<FenceTime>& presentFenceTime) {
1181    // Update queue of past composite+present times and determine the
1182    // most recently known composite to present latency.
1183    mCompositePresentTimes.push({compositeTime, presentFenceTime});
1184    nsecs_t compositeToPresentLatency = -1;
1185    while (!mCompositePresentTimes.empty()) {
1186        CompositePresentTime& cpt = mCompositePresentTimes.front();
1187        // Cached values should have been updated before calling this method,
1188        // which helps avoid duplicate syscalls.
1189        nsecs_t displayTime = cpt.display->getCachedSignalTime();
1190        if (displayTime == Fence::SIGNAL_TIME_PENDING) {
1191            break;
1192        }
1193        compositeToPresentLatency = displayTime - cpt.composite;
1194        mCompositePresentTimes.pop();
1195    }
1196
1197    // Don't let mCompositePresentTimes grow unbounded, just in case.
1198    while (mCompositePresentTimes.size() > 16) {
1199        mCompositePresentTimes.pop();
1200    }
1201
1202    setCompositorTimingSnapped(
1203            vsyncPhase, vsyncInterval, compositeToPresentLatency);
1204}
1205
1206void SurfaceFlinger::setCompositorTimingSnapped(nsecs_t vsyncPhase,
1207        nsecs_t vsyncInterval, nsecs_t compositeToPresentLatency) {
1208    // Integer division and modulo round toward 0 not -inf, so we need to
1209    // treat negative and positive offsets differently.
1210    nsecs_t idealLatency = (sfVsyncPhaseOffsetNs > 0) ?
1211            (vsyncInterval - (sfVsyncPhaseOffsetNs % vsyncInterval)) :
1212            ((-sfVsyncPhaseOffsetNs) % vsyncInterval);
1213
1214    // Just in case sfVsyncPhaseOffsetNs == -vsyncInterval.
1215    if (idealLatency <= 0) {
1216        idealLatency = vsyncInterval;
1217    }
1218
1219    // Snap the latency to a value that removes scheduling jitter from the
1220    // composition and present times, which often have >1ms of jitter.
1221    // Reducing jitter is important if an app attempts to extrapolate
1222    // something (such as user input) to an accurate diasplay time.
1223    // Snapping also allows an app to precisely calculate sfVsyncPhaseOffsetNs
1224    // with (presentLatency % interval).
1225    nsecs_t bias = vsyncInterval / 2;
1226    int64_t extraVsyncs =
1227            (compositeToPresentLatency - idealLatency + bias) / vsyncInterval;
1228    nsecs_t snappedCompositeToPresentLatency = (extraVsyncs > 0) ?
1229            idealLatency + (extraVsyncs * vsyncInterval) : idealLatency;
1230
1231    std::lock_guard<std::mutex> lock(mCompositorTimingLock);
1232    mCompositorTiming.deadline = vsyncPhase - idealLatency;
1233    mCompositorTiming.interval = vsyncInterval;
1234    mCompositorTiming.presentLatency = snappedCompositeToPresentLatency;
1235}
1236
1237void SurfaceFlinger::postComposition(nsecs_t refreshStartTime)
1238{
1239    const HWComposer& hwc = getHwComposer();
1240    const sp<const DisplayDevice> hw(getDefaultDisplayDevice());
1241
1242    std::shared_ptr<FenceTime> glCompositionDoneFenceTime;
1243    if (getHwComposer().hasGlesComposition(hw->getHwcDisplayId())) {
1244        glCompositionDoneFenceTime =
1245                std::make_shared<FenceTime>(hw->getClientTargetAcquireFence());
1246        mGlCompositionDoneTimeline.push(glCompositionDoneFenceTime);
1247    } else {
1248        glCompositionDoneFenceTime = FenceTime::NO_FENCE;
1249    }
1250    mGlCompositionDoneTimeline.updateSignalTimes();
1251
1252    sp<Fence> retireFence = mHwc->getDisplayFence(HWC_DISPLAY_PRIMARY);
1253    auto retireFenceTime = std::make_shared<FenceTime>(retireFence);
1254    mDisplayTimeline.push(retireFenceTime);
1255    mDisplayTimeline.updateSignalTimes();
1256
1257    nsecs_t vsyncPhase = mPrimaryDispSync.computeNextRefresh(0);
1258    nsecs_t vsyncInterval = mPrimaryDispSync.getPeriod();
1259
1260    // We use the refreshStartTime which might be sampled a little later than
1261    // when we started doing work for this frame, but that should be okay
1262    // since updateCompositorTiming has snapping logic.
1263    updateCompositorTiming(
1264        vsyncPhase, vsyncInterval, refreshStartTime, retireFenceTime);
1265    CompositorTiming compositorTiming;
1266    {
1267        std::lock_guard<std::mutex> lock(mCompositorTimingLock);
1268        compositorTiming = mCompositorTiming;
1269    }
1270
1271    mDrawingState.traverseInZOrder([&](Layer* layer) {
1272        // TODO(brianderson): The retire fence is incorrectly passed in as the
1273        // present fence. Fix this if this file lives on.
1274        bool frameLatched = layer->onPostComposition(glCompositionDoneFenceTime,
1275                retireFenceTime, compositorTiming);
1276        if (frameLatched) {
1277            recordBufferingStats(layer->getName().string(),
1278                    layer->getOccupancyHistory(false));
1279        }
1280    });
1281
1282    if (retireFence->isValid()) {
1283        if (mPrimaryDispSync.addPresentFence(retireFence)) {
1284            enableHardwareVsync();
1285        } else {
1286            disableHardwareVsync(false);
1287        }
1288    }
1289
1290    if (!hasSyncFramework) {
1291        if (hw->isDisplayOn()) {
1292            enableHardwareVsync();
1293        }
1294    }
1295
1296    if (mAnimCompositionPending) {
1297        mAnimCompositionPending = false;
1298
1299        if (retireFenceTime->isValid()) {
1300            mAnimFrameTracker.setActualPresentFence(std::move(retireFenceTime));
1301        } else {
1302            // The HWC doesn't support present fences, so use the refresh
1303            // timestamp instead.
1304            nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY);
1305            mAnimFrameTracker.setActualPresentTime(presentTime);
1306        }
1307        mAnimFrameTracker.advanceFrame();
1308    }
1309
1310    if (hw->getPowerMode() == HWC_POWER_MODE_OFF) {
1311        return;
1312    }
1313
1314    nsecs_t currentTime = systemTime();
1315    if (mHasPoweredOff) {
1316        mHasPoweredOff = false;
1317    } else {
1318        nsecs_t period = mPrimaryDispSync.getPeriod();
1319        nsecs_t elapsedTime = currentTime - mLastSwapTime;
1320        size_t numPeriods = static_cast<size_t>(elapsedTime / period);
1321        if (numPeriods < NUM_BUCKETS - 1) {
1322            mFrameBuckets[numPeriods] += elapsedTime;
1323        } else {
1324            mFrameBuckets[NUM_BUCKETS - 1] += elapsedTime;
1325        }
1326        mTotalTime += elapsedTime;
1327    }
1328    mLastSwapTime = currentTime;
1329}
1330
1331void SurfaceFlinger::rebuildLayerStacks() {
1332    // rebuild the visible layer list per screen
1333    if (CC_UNLIKELY(mVisibleRegionsDirty)) {
1334        ATRACE_CALL();
1335        mVisibleRegionsDirty = false;
1336        invalidateHwcGeometry();
1337
1338        for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1339            Region opaqueRegion;
1340            Region dirtyRegion;
1341            Vector< sp<Layer> > layersSortedByZ;
1342            const sp<DisplayDevice>& hw(mDisplays[dpy]);
1343            const Transform& tr(hw->getTransform());
1344            const Rect bounds(hw->getBounds());
1345            if (hw->isDisplayOn()) {
1346                computeVisibleRegions(hw->getLayerStack(), dirtyRegion,
1347                        opaqueRegion);
1348
1349                mDrawingState.traverseInZOrder([&](Layer* layer) {
1350                    if (layer->getLayerStack() == hw->getLayerStack()) {
1351                        Region drawRegion(tr.transform(
1352                                layer->visibleNonTransparentRegion));
1353                        drawRegion.andSelf(bounds);
1354                        if (!drawRegion.isEmpty()) {
1355                            layersSortedByZ.add(layer);
1356                        }
1357                    }
1358                });
1359            }
1360            hw->setVisibleLayersSortedByZ(layersSortedByZ);
1361            hw->undefinedRegion.set(bounds);
1362            hw->undefinedRegion.subtractSelf(tr.transform(opaqueRegion));
1363            hw->dirtyRegion.orSelf(dirtyRegion);
1364        }
1365    }
1366}
1367
1368void SurfaceFlinger::setUpHWComposer() {
1369    for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1370        bool dirty = !mDisplays[dpy]->getDirtyRegion(false).isEmpty();
1371        bool empty = mDisplays[dpy]->getVisibleLayersSortedByZ().size() == 0;
1372        bool wasEmpty = !mDisplays[dpy]->lastCompositionHadVisibleLayers;
1373
1374        // If nothing has changed (!dirty), don't recompose.
1375        // If something changed, but we don't currently have any visible layers,
1376        //   and didn't when we last did a composition, then skip it this time.
1377        // The second rule does two things:
1378        // - When all layers are removed from a display, we'll emit one black
1379        //   frame, then nothing more until we get new layers.
1380        // - When a display is created with a private layer stack, we won't
1381        //   emit any black frames until a layer is added to the layer stack.
1382        bool mustRecompose = dirty && !(empty && wasEmpty);
1383
1384        ALOGV_IF(mDisplays[dpy]->getDisplayType() == DisplayDevice::DISPLAY_VIRTUAL,
1385                "dpy[%zu]: %s composition (%sdirty %sempty %swasEmpty)", dpy,
1386                mustRecompose ? "doing" : "skipping",
1387                dirty ? "+" : "-",
1388                empty ? "+" : "-",
1389                wasEmpty ? "+" : "-");
1390
1391        mDisplays[dpy]->beginFrame(mustRecompose);
1392
1393        if (mustRecompose) {
1394            mDisplays[dpy]->lastCompositionHadVisibleLayers = !empty;
1395        }
1396    }
1397
1398    HWComposer& hwc(getHwComposer());
1399    if (hwc.initCheck() == NO_ERROR) {
1400        // build the h/w work list
1401        if (CC_UNLIKELY(mHwWorkListDirty)) {
1402            mHwWorkListDirty = false;
1403            for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1404                sp<const DisplayDevice> hw(mDisplays[dpy]);
1405                const int32_t id = hw->getHwcDisplayId();
1406                if (id >= 0) {
1407                    const Vector< sp<Layer> >& currentLayers(
1408                        hw->getVisibleLayersSortedByZ());
1409                    const size_t count = currentLayers.size();
1410                    if (hwc.createWorkList(id, count) == NO_ERROR) {
1411                        HWComposer::LayerListIterator cur = hwc.begin(id);
1412                        const HWComposer::LayerListIterator end = hwc.end(id);
1413                        for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1414                            const sp<Layer>& layer(currentLayers[i]);
1415                            layer->setGeometry(hw, *cur);
1416                            if (mDebugDisableHWC || mDebugRegion || mDaltonize || mHasColorMatrix) {
1417                                cur->setSkip(true);
1418                            }
1419                        }
1420                    }
1421                }
1422            }
1423        }
1424
1425        // set the per-frame data
1426        for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1427            sp<const DisplayDevice> hw(mDisplays[dpy]);
1428            const int32_t id = hw->getHwcDisplayId();
1429            if (id >= 0) {
1430                const Vector< sp<Layer> >& currentLayers(
1431                    hw->getVisibleLayersSortedByZ());
1432                const size_t count = currentLayers.size();
1433                HWComposer::LayerListIterator cur = hwc.begin(id);
1434                const HWComposer::LayerListIterator end = hwc.end(id);
1435                for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1436                    /*
1437                     * update the per-frame h/w composer data for each layer
1438                     * and build the transparent region of the FB
1439                     */
1440                    const sp<Layer>& layer(currentLayers[i]);
1441                    layer->setPerFrameData(hw, *cur);
1442                }
1443            }
1444        }
1445
1446        // If possible, attempt to use the cursor overlay on each display.
1447        for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1448            sp<const DisplayDevice> hw(mDisplays[dpy]);
1449            const int32_t id = hw->getHwcDisplayId();
1450            if (id >= 0) {
1451                const Vector< sp<Layer> >& currentLayers(
1452                    hw->getVisibleLayersSortedByZ());
1453                const size_t count = currentLayers.size();
1454                HWComposer::LayerListIterator cur = hwc.begin(id);
1455                const HWComposer::LayerListIterator end = hwc.end(id);
1456                for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1457                    const sp<Layer>& layer(currentLayers[i]);
1458                    if (layer->isPotentialCursor()) {
1459                        cur->setIsCursorLayerHint();
1460                        break;
1461                    }
1462                }
1463            }
1464        }
1465
1466        status_t err = hwc.prepare();
1467        ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err));
1468
1469        for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1470            sp<const DisplayDevice> hw(mDisplays[dpy]);
1471            hw->prepareFrame(hwc);
1472        }
1473    }
1474}
1475
1476void SurfaceFlinger::doComposition() {
1477    ATRACE_CALL();
1478    const bool repaintEverything = android_atomic_and(0, &mRepaintEverything);
1479    for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1480        const sp<DisplayDevice>& hw(mDisplays[dpy]);
1481        if (hw->isDisplayOn()) {
1482            // transform the dirty region into this screen's coordinate space
1483            const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));
1484
1485            // repaint the framebuffer (if needed)
1486            doDisplayComposition(hw, dirtyRegion);
1487
1488            hw->dirtyRegion.clear();
1489            hw->flip(hw->swapRegion);
1490            hw->swapRegion.clear();
1491        }
1492        // inform the h/w that we're done compositing
1493        hw->compositionComplete();
1494    }
1495    postFramebuffer();
1496}
1497
1498void SurfaceFlinger::postFramebuffer()
1499{
1500    ATRACE_CALL();
1501
1502    const nsecs_t now = systemTime();
1503    mDebugInSwapBuffers = now;
1504
1505    HWComposer& hwc(getHwComposer());
1506    if (hwc.initCheck() == NO_ERROR) {
1507        if (!hwc.supportsFramebufferTarget()) {
1508            // EGL spec says:
1509            //   "surface must be bound to the calling thread's current context,
1510            //    for the current rendering API."
1511            getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
1512        }
1513        hwc.commit();
1514    }
1515
1516    // make the default display current because the VirtualDisplayDevice code cannot
1517    // deal with dequeueBuffer() being called outside of the composition loop; however
1518    // the code below can call glFlush() which is allowed (and does in some case) call
1519    // dequeueBuffer().
1520    getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
1521
1522    for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1523        sp<const DisplayDevice> hw(mDisplays[dpy]);
1524        const Vector< sp<Layer> >& currentLayers(hw->getVisibleLayersSortedByZ());
1525        hw->onSwapBuffersCompleted(hwc);
1526        const size_t count = currentLayers.size();
1527        int32_t id = hw->getHwcDisplayId();
1528        if (id >=0 && hwc.initCheck() == NO_ERROR) {
1529            HWComposer::LayerListIterator cur = hwc.begin(id);
1530            const HWComposer::LayerListIterator end = hwc.end(id);
1531            for (size_t i = 0; cur != end && i < count; ++i, ++cur) {
1532                currentLayers[i]->onLayerDisplayed(hw, &*cur);
1533            }
1534        } else {
1535            for (size_t i = 0; i < count; i++) {
1536                currentLayers[i]->onLayerDisplayed(hw, NULL);
1537            }
1538        }
1539    }
1540
1541    mLastSwapBufferTime = systemTime() - now;
1542    mDebugInSwapBuffers = 0;
1543
1544    uint32_t flipCount = getDefaultDisplayDevice()->getPageFlipCount();
1545    if (flipCount % LOG_FRAME_STATS_PERIOD == 0) {
1546        logFrameStats();
1547    }
1548}
1549
1550void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
1551{
1552    ATRACE_CALL();
1553
1554    // here we keep a copy of the drawing state (that is the state that's
1555    // going to be overwritten by handleTransactionLocked()) outside of
1556    // mStateLock so that the side-effects of the State assignment
1557    // don't happen with mStateLock held (which can cause deadlocks).
1558    State drawingState(mDrawingState);
1559
1560    Mutex::Autolock _l(mStateLock);
1561    const nsecs_t now = systemTime();
1562    mDebugInTransaction = now;
1563
1564    // Here we're guaranteed that some transaction flags are set
1565    // so we can call handleTransactionLocked() unconditionally.
1566    // We call getTransactionFlags(), which will also clear the flags,
1567    // with mStateLock held to guarantee that mCurrentState won't change
1568    // until the transaction is committed.
1569
1570    transactionFlags = getTransactionFlags(eTransactionMask);
1571    handleTransactionLocked(transactionFlags);
1572
1573    mLastTransactionTime = systemTime() - now;
1574    mDebugInTransaction = 0;
1575    invalidateHwcGeometry();
1576    // here the transaction has been committed
1577}
1578
1579void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
1580{
1581    // Notify all layers of available frames
1582    mCurrentState.traverseInZOrder([](Layer* layer) {
1583        layer->notifyAvailableFrames();
1584    });
1585
1586    /*
1587     * Traversal of the children
1588     * (perform the transaction for each of them if needed)
1589     */
1590
1591    if (transactionFlags & eTraversalNeeded) {
1592        mCurrentState.traverseInZOrder([&](Layer* layer) {
1593            uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
1594            if (!trFlags) return;
1595
1596            const uint32_t flags = layer->doTransaction(0);
1597            if (flags & Layer::eVisibleRegion)
1598                mVisibleRegionsDirty = true;
1599        });
1600    }
1601
1602    /*
1603     * Perform display own transactions if needed
1604     */
1605
1606    if (transactionFlags & eDisplayTransactionNeeded) {
1607        // here we take advantage of Vector's copy-on-write semantics to
1608        // improve performance by skipping the transaction entirely when
1609        // know that the lists are identical
1610        const KeyedVector<  wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
1611        const KeyedVector<  wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);
1612        if (!curr.isIdenticalTo(draw)) {
1613            mVisibleRegionsDirty = true;
1614            const size_t cc = curr.size();
1615                  size_t dc = draw.size();
1616
1617            // find the displays that were removed
1618            // (ie: in drawing state but not in current state)
1619            // also handle displays that changed
1620            // (ie: displays that are in both lists)
1621            for (size_t i=0 ; i<dc ; i++) {
1622                const ssize_t j = curr.indexOfKey(draw.keyAt(i));
1623                if (j < 0) {
1624                    // in drawing state but not in current state
1625                    if (!draw[i].isMainDisplay()) {
1626                        // Call makeCurrent() on the primary display so we can
1627                        // be sure that nothing associated with this display
1628                        // is current.
1629                        const sp<const DisplayDevice> defaultDisplay(getDefaultDisplayDevice());
1630                        defaultDisplay->makeCurrent(mEGLDisplay, mEGLContext);
1631                        sp<DisplayDevice> hw(getDisplayDevice(draw.keyAt(i)));
1632                        if (hw != NULL)
1633                            hw->disconnect(getHwComposer());
1634                        if (draw[i].type < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES)
1635                            mEventThread->onHotplugReceived(draw[i].type, false);
1636                        mDisplays.removeItem(draw.keyAt(i));
1637                    } else {
1638                        ALOGW("trying to remove the main display");
1639                    }
1640                } else {
1641                    // this display is in both lists. see if something changed.
1642                    const DisplayDeviceState& state(curr[j]);
1643                    const wp<IBinder>& display(curr.keyAt(j));
1644                    const sp<IBinder> state_binder = IInterface::asBinder(state.surface);
1645                    const sp<IBinder> draw_binder = IInterface::asBinder(draw[i].surface);
1646                    if (state_binder != draw_binder) {
1647                        // changing the surface is like destroying and
1648                        // recreating the DisplayDevice, so we just remove it
1649                        // from the drawing state, so that it get re-added
1650                        // below.
1651                        sp<DisplayDevice> hw(getDisplayDevice(display));
1652                        if (hw != NULL)
1653                            hw->disconnect(getHwComposer());
1654                        mDisplays.removeItem(display);
1655                        mDrawingState.displays.removeItemsAt(i);
1656                        dc--; i--;
1657                        // at this point we must loop to the next item
1658                        continue;
1659                    }
1660
1661                    const sp<DisplayDevice> disp(getDisplayDevice(display));
1662                    if (disp != NULL) {
1663                        if (state.layerStack != draw[i].layerStack) {
1664                            disp->setLayerStack(state.layerStack);
1665                        }
1666                        if ((state.orientation != draw[i].orientation)
1667                                || (state.viewport != draw[i].viewport)
1668                                || (state.frame != draw[i].frame))
1669                        {
1670                            disp->setProjection(state.orientation,
1671                                    state.viewport, state.frame);
1672                        }
1673                        if (state.width != draw[i].width || state.height != draw[i].height) {
1674                            disp->setDisplaySize(state.width, state.height);
1675                        }
1676                    }
1677                }
1678            }
1679
1680            // find displays that were added
1681            // (ie: in current state but not in drawing state)
1682            for (size_t i=0 ; i<cc ; i++) {
1683                if (draw.indexOfKey(curr.keyAt(i)) < 0) {
1684                    const DisplayDeviceState& state(curr[i]);
1685
1686                    sp<DisplaySurface> dispSurface;
1687                    sp<IGraphicBufferProducer> producer;
1688                    sp<IGraphicBufferProducer> bqProducer;
1689                    sp<IGraphicBufferConsumer> bqConsumer;
1690                    BufferQueue::createBufferQueue(&bqProducer, &bqConsumer,
1691                            new GraphicBufferAlloc());
1692
1693                    int32_t hwcDisplayId = -1;
1694                    if (state.isVirtualDisplay()) {
1695                        // Virtual displays without a surface are dormant:
1696                        // they have external state (layer stack, projection,
1697                        // etc.) but no internal state (i.e. a DisplayDevice).
1698                        if (state.surface != NULL) {
1699
1700                            int width = 0;
1701                            int status = state.surface->query(
1702                                    NATIVE_WINDOW_WIDTH, &width);
1703                            ALOGE_IF(status != NO_ERROR,
1704                                    "Unable to query width (%d)", status);
1705                            int height = 0;
1706                            status = state.surface->query(
1707                                    NATIVE_WINDOW_HEIGHT, &height);
1708                            ALOGE_IF(status != NO_ERROR,
1709                                    "Unable to query height (%d)", status);
1710                            if (mUseHwcVirtualDisplays &&
1711                                    (SurfaceFlinger::maxVirtualDisplaySize == 0 ||
1712                                    (width <= static_cast<int>(SurfaceFlinger::maxVirtualDisplaySize) &&
1713                                     height <= static_cast<int>(SurfaceFlinger::maxVirtualDisplaySize)))) {
1714                                hwcDisplayId = allocateHwcDisplayId(state.type);
1715                            }
1716
1717                            sp<VirtualDisplaySurface> vds = new VirtualDisplaySurface(
1718                                    *mHwc, hwcDisplayId, state.surface,
1719                                    bqProducer, bqConsumer, state.displayName);
1720
1721                            dispSurface = vds;
1722                            producer = vds;
1723                        }
1724                    } else {
1725                        ALOGE_IF(state.surface!=NULL,
1726                                "adding a supported display, but rendering "
1727                                "surface is provided (%p), ignoring it",
1728                                state.surface.get());
1729                        hwcDisplayId = allocateHwcDisplayId(state.type);
1730                        // for supported (by hwc) displays we provide our
1731                        // own rendering surface
1732                        dispSurface = new FramebufferSurface(*mHwc, state.type,
1733                                bqConsumer);
1734                        producer = bqProducer;
1735                    }
1736
1737                    const wp<IBinder>& display(curr.keyAt(i));
1738                    if (dispSurface != NULL) {
1739                        sp<DisplayDevice> hw = new DisplayDevice(this,
1740                                state.type, hwcDisplayId,
1741                                mHwc->getFormat(hwcDisplayId), state.isSecure,
1742                                display, dispSurface, producer,
1743                                mRenderEngine->getEGLConfig());
1744                        hw->setLayerStack(state.layerStack);
1745                        hw->setProjection(state.orientation,
1746                                state.viewport, state.frame);
1747                        hw->setDisplayName(state.displayName);
1748                        mDisplays.add(display, hw);
1749                        if (state.isVirtualDisplay()) {
1750                            if (hwcDisplayId >= 0) {
1751                                mHwc->setVirtualDisplayProperties(hwcDisplayId,
1752                                        hw->getWidth(), hw->getHeight(),
1753                                        hw->getFormat());
1754                            }
1755                        } else {
1756                            mEventThread->onHotplugReceived(state.type, true);
1757                        }
1758                    }
1759                }
1760            }
1761        }
1762    }
1763
1764    if (transactionFlags & (eTraversalNeeded|eDisplayTransactionNeeded)) {
1765        // The transform hint might have changed for some layers
1766        // (either because a display has changed, or because a layer
1767        // as changed).
1768        //
1769        // Walk through all the layers in currentLayers,
1770        // and update their transform hint.
1771        //
1772        // If a layer is visible only on a single display, then that
1773        // display is used to calculate the hint, otherwise we use the
1774        // default display.
1775        //
1776        // NOTE: we do this here, rather than in rebuildLayerStacks() so that
1777        // the hint is set before we acquire a buffer from the surface texture.
1778        //
1779        // NOTE: layer transactions have taken place already, so we use their
1780        // drawing state. However, SurfaceFlinger's own transaction has not
1781        // happened yet, so we must use the current state layer list
1782        // (soon to become the drawing state list).
1783        //
1784        sp<const DisplayDevice> disp;
1785        uint32_t currentlayerStack = 0;
1786        bool first = true;
1787        mCurrentState.traverseInZOrder([&](Layer* layer) {
1788            // NOTE: we rely on the fact that layers are sorted by
1789            // layerStack first (so we don't have to traverse the list
1790            // of displays for every layer).
1791            uint32_t layerStack = layer->getLayerStack();
1792            if (first || currentlayerStack != layerStack) {
1793                currentlayerStack = layerStack;
1794                // figure out if this layerstack is mirrored
1795                // (more than one display) if so, pick the default display,
1796                // if not, pick the only display it's on.
1797                disp.clear();
1798                for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1799                    sp<const DisplayDevice> hw(mDisplays[dpy]);
1800                    if (hw->getLayerStack() == currentlayerStack) {
1801                        if (disp == NULL) {
1802                            disp = hw;
1803                        } else {
1804                            disp = NULL;
1805                            break;
1806                        }
1807                    }
1808                }
1809            }
1810            if (disp == NULL) {
1811                // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to
1812                // redraw after transform hint changes. See bug 8508397.
1813
1814                // could be null when this layer is using a layerStack
1815                // that is not visible on any display. Also can occur at
1816                // screen off/on times.
1817                disp = getDefaultDisplayDevice();
1818            }
1819            layer->updateTransformHint(disp);
1820
1821            first = false;
1822        });
1823    }
1824
1825
1826    /*
1827     * Perform our own transaction if needed
1828     */
1829
1830    if (mLayersAdded) {
1831        mLayersAdded = false;
1832        // Layers have been added.
1833        mVisibleRegionsDirty = true;
1834    }
1835
1836    // some layers might have been removed, so
1837    // we need to update the regions they're exposing.
1838    if (mLayersRemoved) {
1839        mLayersRemoved = false;
1840        mVisibleRegionsDirty = true;
1841        mDrawingState.traverseInZOrder([&](Layer* layer) {
1842            if (mLayersPendingRemoval.indexOf(layer) >= 0) {
1843                // this layer is not visible anymore
1844                // TODO: we could traverse the tree from front to back and
1845                //       compute the actual visible region
1846                // TODO: we could cache the transformed region
1847                Region visibleReg;
1848                visibleReg.set(layer->computeScreenBounds());
1849                invalidateLayerStack(layer->getLayerStack(), visibleReg);
1850            }
1851        });
1852    }
1853
1854    commitTransaction();
1855
1856    updateCursorAsync();
1857}
1858
1859void SurfaceFlinger::updateCursorAsync()
1860{
1861    HWComposer& hwc(getHwComposer());
1862    for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1863        sp<const DisplayDevice> hw(mDisplays[dpy]);
1864        const int32_t id = hw->getHwcDisplayId();
1865        if (id < 0) {
1866            continue;
1867        }
1868        const Vector< sp<Layer> >& currentLayers(
1869            hw->getVisibleLayersSortedByZ());
1870        const size_t count = currentLayers.size();
1871        HWComposer::LayerListIterator cur = hwc.begin(id);
1872        const HWComposer::LayerListIterator end = hwc.end(id);
1873        for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1874            if (cur->getCompositionType() != HWC_CURSOR_OVERLAY) {
1875                continue;
1876            }
1877            const sp<Layer>& layer(currentLayers[i]);
1878            Rect cursorPos = layer->getPosition(hw);
1879            hwc.setCursorPositionAsync(id, cursorPos);
1880            break;
1881        }
1882    }
1883}
1884
1885void SurfaceFlinger::commitTransaction()
1886{
1887    if (!mLayersPendingRemoval.isEmpty()) {
1888        // Notify removed layers now that they can't be drawn from
1889        for (const auto& l : mLayersPendingRemoval) {
1890            recordBufferingStats(l->getName().string(),
1891                    l->getOccupancyHistory(true));
1892            l->onRemoved();
1893        }
1894        mLayersPendingRemoval.clear();
1895    }
1896
1897    // If this transaction is part of a window animation then the next frame
1898    // we composite should be considered an animation as well.
1899    mAnimCompositionPending = mAnimTransactionPending;
1900
1901    mDrawingState = mCurrentState;
1902    mDrawingState.traverseInZOrder([](Layer* layer) {
1903        layer->commitChildList();
1904    });
1905    mTransactionPending = false;
1906    mAnimTransactionPending = false;
1907    mTransactionCV.broadcast();
1908}
1909
1910void SurfaceFlinger::computeVisibleRegions(uint32_t layerStack,
1911        Region& outDirtyRegion, Region& outOpaqueRegion)
1912{
1913    ATRACE_CALL();
1914
1915    Region aboveOpaqueLayers;
1916    Region aboveCoveredLayers;
1917    Region dirty;
1918
1919    outDirtyRegion.clear();
1920
1921    mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
1922        // start with the whole surface at its current location
1923        const Layer::State& s(layer->getDrawingState());
1924
1925        // only consider the layers on the given layer stack
1926        if (layer->getLayerStack() != layerStack)
1927            return;
1928
1929        /*
1930         * opaqueRegion: area of a surface that is fully opaque.
1931         */
1932        Region opaqueRegion;
1933
1934        /*
1935         * visibleRegion: area of a surface that is visible on screen
1936         * and not fully transparent. This is essentially the layer's
1937         * footprint minus the opaque regions above it.
1938         * Areas covered by a translucent surface are considered visible.
1939         */
1940        Region visibleRegion;
1941
1942        /*
1943         * coveredRegion: area of a surface that is covered by all
1944         * visible regions above it (which includes the translucent areas).
1945         */
1946        Region coveredRegion;
1947
1948        /*
1949         * transparentRegion: area of a surface that is hinted to be completely
1950         * transparent. This is only used to tell when the layer has no visible
1951         * non-transparent regions and can be removed from the layer list. It
1952         * does not affect the visibleRegion of this layer or any layers
1953         * beneath it. The hint may not be correct if apps don't respect the
1954         * SurfaceView restrictions (which, sadly, some don't).
1955         */
1956        Region transparentRegion;
1957
1958
1959        // handle hidden surfaces by setting the visible region to empty
1960        if (CC_LIKELY(layer->isVisible())) {
1961            const bool translucent = !layer->isOpaque(s);
1962            Rect bounds(layer->computeScreenBounds());
1963            visibleRegion.set(bounds);
1964            Transform tr = layer->getTransform();
1965            if (!visibleRegion.isEmpty()) {
1966                // Remove the transparent area from the visible region
1967                if (translucent) {
1968                    if (tr.preserveRects()) {
1969                        // transform the transparent region
1970                        transparentRegion = tr.transform(s.activeTransparentRegion);
1971                    } else {
1972                        // transformation too complex, can't do the
1973                        // transparent region optimization.
1974                        transparentRegion.clear();
1975                    }
1976                }
1977
1978                // compute the opaque region
1979                const int32_t layerOrientation = tr.getOrientation();
1980                if (s.alpha==255 && !translucent &&
1981                        ((layerOrientation & Transform::ROT_INVALID) == false)) {
1982                    // the opaque region is the layer's footprint
1983                    opaqueRegion = visibleRegion;
1984                }
1985            }
1986        }
1987
1988        // Clip the covered region to the visible region
1989        coveredRegion = aboveCoveredLayers.intersect(visibleRegion);
1990
1991        // Update aboveCoveredLayers for next (lower) layer
1992        aboveCoveredLayers.orSelf(visibleRegion);
1993
1994        // subtract the opaque region covered by the layers above us
1995        visibleRegion.subtractSelf(aboveOpaqueLayers);
1996
1997        // compute this layer's dirty region
1998        if (layer->contentDirty) {
1999            // we need to invalidate the whole region
2000            dirty = visibleRegion;
2001            // as well, as the old visible region
2002            dirty.orSelf(layer->visibleRegion);
2003            layer->contentDirty = false;
2004        } else {
2005            /* compute the exposed region:
2006             *   the exposed region consists of two components:
2007             *   1) what's VISIBLE now and was COVERED before
2008             *   2) what's EXPOSED now less what was EXPOSED before
2009             *
2010             * note that (1) is conservative, we start with the whole
2011             * visible region but only keep what used to be covered by
2012             * something -- which mean it may have been exposed.
2013             *
2014             * (2) handles areas that were not covered by anything but got
2015             * exposed because of a resize.
2016             */
2017            const Region newExposed = visibleRegion - coveredRegion;
2018            const Region oldVisibleRegion = layer->visibleRegion;
2019            const Region oldCoveredRegion = layer->coveredRegion;
2020            const Region oldExposed = oldVisibleRegion - oldCoveredRegion;
2021            dirty = (visibleRegion&oldCoveredRegion) | (newExposed-oldExposed);
2022        }
2023        dirty.subtractSelf(aboveOpaqueLayers);
2024
2025        // accumulate to the screen dirty region
2026        outDirtyRegion.orSelf(dirty);
2027
2028        // Update aboveOpaqueLayers for next (lower) layer
2029        aboveOpaqueLayers.orSelf(opaqueRegion);
2030
2031        // Store the visible region in screen space
2032        layer->setVisibleRegion(visibleRegion);
2033        layer->setCoveredRegion(coveredRegion);
2034        layer->setVisibleNonTransparentRegion(
2035                visibleRegion.subtract(transparentRegion));
2036    });
2037
2038    outOpaqueRegion = aboveOpaqueLayers;
2039}
2040
2041void SurfaceFlinger::invalidateLayerStack(uint32_t layerStack,
2042        const Region& dirty) {
2043    for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
2044        const sp<DisplayDevice>& hw(mDisplays[dpy]);
2045        if (hw->getLayerStack() == layerStack) {
2046            hw->dirtyRegion.orSelf(dirty);
2047        }
2048    }
2049}
2050
2051bool SurfaceFlinger::handlePageFlip()
2052{
2053    nsecs_t latchTime = systemTime();
2054    Region dirtyRegion;
2055
2056    bool visibleRegions = false;
2057    bool frameQueued = false;
2058
2059    // Store the set of layers that need updates. This set must not change as
2060    // buffers are being latched, as this could result in a deadlock.
2061    // Example: Two producers share the same command stream and:
2062    // 1.) Layer 0 is latched
2063    // 2.) Layer 0 gets a new frame
2064    // 2.) Layer 1 gets a new frame
2065    // 3.) Layer 1 is latched.
2066    // Display is now waiting on Layer 1's frame, which is behind layer 0's
2067    // second frame. But layer 0's second frame could be waiting on display.
2068    Vector<Layer*> layersWithQueuedFrames;
2069    mDrawingState.traverseInZOrder([&](Layer* layer) {
2070        if (layer->hasQueuedFrame()) {
2071            frameQueued = true;
2072            if (layer->shouldPresentNow(mPrimaryDispSync)) {
2073                layersWithQueuedFrames.push_back(layer);
2074            } else {
2075                layer->useEmptyDamage();
2076            }
2077        } else {
2078            layer->useEmptyDamage();
2079        }
2080    });
2081    for (size_t i = 0, count = layersWithQueuedFrames.size() ; i<count ; i++) {
2082        Layer* layer = layersWithQueuedFrames[i];
2083        const Region dirty(layer->latchBuffer(visibleRegions, latchTime));
2084        layer->useSurfaceDamage();
2085        invalidateLayerStack(layer->getLayerStack(), dirty);
2086    }
2087
2088    mVisibleRegionsDirty |= visibleRegions;
2089
2090    // If we will need to wake up at some time in the future to deal with a
2091    // queued frame that shouldn't be displayed during this vsync period, wake
2092    // up during the next vsync period to check again.
2093    if (frameQueued && layersWithQueuedFrames.empty()) {
2094        signalLayerUpdate();
2095    }
2096
2097    // Only continue with the refresh if there is actually new work to do
2098    return !layersWithQueuedFrames.empty();
2099}
2100
2101void SurfaceFlinger::invalidateHwcGeometry()
2102{
2103    mHwWorkListDirty = true;
2104}
2105
2106
2107void SurfaceFlinger::doDisplayComposition(const sp<const DisplayDevice>& hw,
2108        const Region& inDirtyRegion)
2109{
2110    // We only need to actually compose the display if:
2111    // 1) It is being handled by hardware composer, which may need this to
2112    //    keep its virtual display state machine in sync, or
2113    // 2) There is work to be done (the dirty region isn't empty)
2114    bool isHwcDisplay = hw->getHwcDisplayId() >= 0;
2115    if (!isHwcDisplay && inDirtyRegion.isEmpty()) {
2116        return;
2117    }
2118
2119    Region dirtyRegion(inDirtyRegion);
2120
2121    // compute the invalid region
2122    hw->swapRegion.orSelf(dirtyRegion);
2123
2124    uint32_t flags = hw->getFlags();
2125    if (flags & DisplayDevice::SWAP_RECTANGLE) {
2126        // we can redraw only what's dirty, but since SWAP_RECTANGLE only
2127        // takes a rectangle, we must make sure to update that whole
2128        // rectangle in that case
2129        dirtyRegion.set(hw->swapRegion.bounds());
2130    } else {
2131        if (flags & DisplayDevice::PARTIAL_UPDATES) {
2132            // We need to redraw the rectangle that will be updated
2133            // (pushed to the framebuffer).
2134            // This is needed because PARTIAL_UPDATES only takes one
2135            // rectangle instead of a region (see DisplayDevice::flip())
2136            dirtyRegion.set(hw->swapRegion.bounds());
2137        } else {
2138            // we need to redraw everything (the whole screen)
2139            dirtyRegion.set(hw->bounds());
2140            hw->swapRegion = dirtyRegion;
2141        }
2142    }
2143
2144    if (CC_LIKELY(!mDaltonize && !mHasColorMatrix)) {
2145        if (!doComposeSurfaces(hw, dirtyRegion)) return;
2146    } else {
2147        RenderEngine& engine(getRenderEngine());
2148        mat4 colorMatrix = mColorMatrix;
2149        if (mDaltonize) {
2150            colorMatrix = colorMatrix * mDaltonizer();
2151        }
2152        mat4 oldMatrix = engine.setupColorTransform(colorMatrix);
2153        doComposeSurfaces(hw, dirtyRegion);
2154        engine.setupColorTransform(oldMatrix);
2155    }
2156
2157    // update the swap region and clear the dirty region
2158    hw->swapRegion.orSelf(dirtyRegion);
2159
2160    // swap buffers (presentation)
2161    hw->swapBuffers(getHwComposer());
2162}
2163
2164bool SurfaceFlinger::doComposeSurfaces(const sp<const DisplayDevice>& hw, const Region& dirty)
2165{
2166    RenderEngine& engine(getRenderEngine());
2167    const int32_t id = hw->getHwcDisplayId();
2168    HWComposer& hwc(getHwComposer());
2169    HWComposer::LayerListIterator cur = hwc.begin(id);
2170    const HWComposer::LayerListIterator end = hwc.end(id);
2171
2172    bool hasGlesComposition = hwc.hasGlesComposition(id);
2173    if (hasGlesComposition) {
2174        if (!hw->makeCurrent(mEGLDisplay, mEGLContext)) {
2175            ALOGW("DisplayDevice::makeCurrent failed. Aborting surface composition for display %s",
2176                  hw->getDisplayName().string());
2177            eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
2178            if(!getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext)) {
2179              ALOGE("DisplayDevice::makeCurrent on default display failed. Aborting.");
2180            }
2181            return false;
2182        }
2183
2184        // Never touch the framebuffer if we don't have any framebuffer layers
2185        const bool hasHwcComposition = hwc.hasHwcComposition(id);
2186        if (hasHwcComposition) {
2187            // when using overlays, we assume a fully transparent framebuffer
2188            // NOTE: we could reduce how much we need to clear, for instance
2189            // remove where there are opaque FB layers. however, on some
2190            // GPUs doing a "clean slate" clear might be more efficient.
2191            // We'll revisit later if needed.
2192            engine.clearWithColor(0, 0, 0, 0);
2193        } else {
2194            // we start with the whole screen area
2195            const Region bounds(hw->getBounds());
2196
2197            // we remove the scissor part
2198            // we're left with the letterbox region
2199            // (common case is that letterbox ends-up being empty)
2200            const Region letterbox(bounds.subtract(hw->getScissor()));
2201
2202            // compute the area to clear
2203            Region region(hw->undefinedRegion.merge(letterbox));
2204
2205            // but limit it to the dirty region
2206            region.andSelf(dirty);
2207
2208            // screen is already cleared here
2209            if (!region.isEmpty()) {
2210                // can happen with SurfaceView
2211                drawWormhole(hw, region);
2212            }
2213        }
2214
2215        if (hw->getDisplayType() != DisplayDevice::DISPLAY_PRIMARY) {
2216            // just to be on the safe side, we don't set the
2217            // scissor on the main display. It should never be needed
2218            // anyways (though in theory it could since the API allows it).
2219            const Rect& bounds(hw->getBounds());
2220            const Rect& scissor(hw->getScissor());
2221            if (scissor != bounds) {
2222                // scissor doesn't match the screen's dimensions, so we
2223                // need to clear everything outside of it and enable
2224                // the GL scissor so we don't draw anything where we shouldn't
2225
2226                // enable scissor for this frame
2227                const uint32_t height = hw->getHeight();
2228                engine.setScissor(scissor.left, height - scissor.bottom,
2229                        scissor.getWidth(), scissor.getHeight());
2230            }
2231        }
2232    }
2233
2234    /*
2235     * and then, render the layers targeted at the framebuffer
2236     */
2237
2238    const Vector< sp<Layer> >& layers(hw->getVisibleLayersSortedByZ());
2239    const size_t count = layers.size();
2240    const Transform& tr = hw->getTransform();
2241    if (cur != end) {
2242        // we're using h/w composer
2243        for (size_t i=0 ; i<count && cur!=end ; ++i, ++cur) {
2244            const sp<Layer>& layer(layers[i]);
2245            const Region clip(dirty.intersect(tr.transform(layer->visibleRegion)));
2246            if (!clip.isEmpty()) {
2247                switch (cur->getCompositionType()) {
2248                    case HWC_CURSOR_OVERLAY:
2249                    case HWC_OVERLAY: {
2250                        const Layer::State& state(layer->getDrawingState());
2251                        if ((cur->getHints() & HWC_HINT_CLEAR_FB)
2252                                && i
2253                                && layer->isOpaque(state) && (state.alpha == 0xFF)
2254                                && hasGlesComposition) {
2255                            // never clear the very first layer since we're
2256                            // guaranteed the FB is already cleared
2257                            layer->clearWithOpenGL(hw);
2258                        }
2259                        break;
2260                    }
2261                    case HWC_FRAMEBUFFER: {
2262                        layer->draw(hw, clip);
2263                        break;
2264                    }
2265                    case HWC_FRAMEBUFFER_TARGET: {
2266                        // this should not happen as the iterator shouldn't
2267                        // let us get there.
2268                        ALOGW("HWC_FRAMEBUFFER_TARGET found in hwc list (index=%zu)", i);
2269                        break;
2270                    }
2271                }
2272            }
2273            layer->setAcquireFence(hw, *cur);
2274        }
2275    } else {
2276        // we're not using h/w composer
2277        for (size_t i=0 ; i<count ; ++i) {
2278            const sp<Layer>& layer(layers[i]);
2279            const Region clip(dirty.intersect(
2280                    tr.transform(layer->visibleRegion)));
2281            if (!clip.isEmpty()) {
2282                layer->draw(hw, clip);
2283            }
2284        }
2285    }
2286
2287    // disable scissor at the end of the frame
2288    engine.disableScissor();
2289    return true;
2290}
2291
2292void SurfaceFlinger::drawWormhole(const sp<const DisplayDevice>& hw, const Region& region) const {
2293    const int32_t height = hw->getHeight();
2294    RenderEngine& engine(getRenderEngine());
2295    engine.fillRegionWithColor(region, height, 0, 0, 0, 0);
2296}
2297
2298status_t SurfaceFlinger::addClientLayer(const sp<Client>& client,
2299        const sp<IBinder>& handle,
2300        const sp<IGraphicBufferProducer>& gbc,
2301        const sp<Layer>& lbc,
2302        const sp<Layer>& parent)
2303{
2304    // add this layer to the current state list
2305    {
2306        Mutex::Autolock _l(mStateLock);
2307        if (mNumLayers >= MAX_LAYERS) {
2308            return NO_MEMORY;
2309        }
2310        if (parent == nullptr) {
2311            mCurrentState.layersSortedByZ.add(lbc);
2312        } else {
2313            parent->addChild(lbc);
2314        }
2315        mGraphicBufferProducerList.add(IInterface::asBinder(gbc));
2316        mLayersAdded = true;
2317        mNumLayers++;
2318    }
2319
2320    // attach this layer to the client
2321    client->attachLayer(handle, lbc);
2322
2323    return NO_ERROR;
2324}
2325
2326status_t SurfaceFlinger::removeLayer(const sp<Layer>& layer) {
2327    Mutex::Autolock _l(mStateLock);
2328
2329    const auto& p = layer->getParent();
2330    const ssize_t index = (p != nullptr) ? p->removeChild(layer) :
2331             mCurrentState.layersSortedByZ.remove(layer);
2332
2333    // As a matter of normal operation, the LayerCleaner will produce a second
2334    // attempt to remove the surface. The Layer will be kept alive in mDrawingState
2335    // so we will succeed in promoting it, but it's already been removed
2336    // from mCurrentState. As long as we can find it in mDrawingState we have no problem
2337    // otherwise something has gone wrong and we are leaking the layer.
2338    if (index < 0 && mDrawingState.layersSortedByZ.indexOf(layer) < 0) {
2339        ALOGE("Failed to find layer (%s) in layer parent (%s).",
2340                layer->getName().string(),
2341                (p != nullptr) ? p->getName().string() : "no-parent");
2342        return BAD_VALUE;
2343    } else if (index < 0) {
2344        return NO_ERROR;
2345    }
2346
2347    mLayersPendingRemoval.add(layer);
2348    mLayersRemoved = true;
2349    mNumLayers--;
2350    setTransactionFlags(eTransactionNeeded);
2351    return NO_ERROR;
2352}
2353
2354uint32_t SurfaceFlinger::peekTransactionFlags() {
2355    return android_atomic_release_load(&mTransactionFlags);
2356}
2357
2358uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags) {
2359    return android_atomic_and(~flags, &mTransactionFlags) & flags;
2360}
2361
2362uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags) {
2363    uint32_t old = android_atomic_or(flags, &mTransactionFlags);
2364    if ((old & flags)==0) { // wake the server up
2365        signalTransaction();
2366    }
2367    return old;
2368}
2369
2370void SurfaceFlinger::setTransactionState(
2371        const Vector<ComposerState>& state,
2372        const Vector<DisplayState>& displays,
2373        uint32_t flags)
2374{
2375    ATRACE_CALL();
2376    Mutex::Autolock _l(mStateLock);
2377    uint32_t transactionFlags = 0;
2378
2379    if (flags & eAnimation) {
2380        // For window updates that are part of an animation we must wait for
2381        // previous animation "frames" to be handled.
2382        while (mAnimTransactionPending) {
2383            status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
2384            if (CC_UNLIKELY(err != NO_ERROR)) {
2385                // just in case something goes wrong in SF, return to the
2386                // caller after a few seconds.
2387                ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out "
2388                        "waiting for previous animation frame");
2389                mAnimTransactionPending = false;
2390                break;
2391            }
2392        }
2393    }
2394
2395    size_t count = displays.size();
2396    for (size_t i=0 ; i<count ; i++) {
2397        const DisplayState& s(displays[i]);
2398        transactionFlags |= setDisplayStateLocked(s);
2399    }
2400
2401    count = state.size();
2402    for (size_t i=0 ; i<count ; i++) {
2403        const ComposerState& s(state[i]);
2404        // Here we need to check that the interface we're given is indeed
2405        // one of our own. A malicious client could give us a NULL
2406        // IInterface, or one of its own or even one of our own but a
2407        // different type. All these situations would cause us to crash.
2408        //
2409        // NOTE: it would be better to use RTTI as we could directly check
2410        // that we have a Client*. however, RTTI is disabled in Android.
2411        if (s.client != NULL) {
2412            sp<IBinder> binder = IInterface::asBinder(s.client);
2413            if (binder != NULL) {
2414                if (binder->queryLocalInterface(ISurfaceComposerClient::descriptor) != NULL) {
2415                    sp<Client> client( static_cast<Client *>(s.client.get()) );
2416                    transactionFlags |= setClientStateLocked(client, s.state);
2417                }
2418            }
2419        }
2420    }
2421
2422    // If a synchronous transaction is explicitly requested without any changes,
2423    // force a transaction anyway. This can be used as a flush mechanism for
2424    // previous async transactions.
2425    if (transactionFlags == 0 && (flags & eSynchronous)) {
2426        transactionFlags = eTransactionNeeded;
2427    }
2428
2429    if (transactionFlags) {
2430        if (mInterceptor.isEnabled()) {
2431            mInterceptor.saveTransaction(state, mCurrentState.displays, displays, flags);
2432        }
2433
2434        // this triggers the transaction
2435        setTransactionFlags(transactionFlags);
2436
2437        // if this is a synchronous transaction, wait for it to take effect
2438        // before returning.
2439        if (flags & eSynchronous) {
2440            mTransactionPending = true;
2441        }
2442        if (flags & eAnimation) {
2443            mAnimTransactionPending = true;
2444        }
2445        while (mTransactionPending) {
2446            status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
2447            if (CC_UNLIKELY(err != NO_ERROR)) {
2448                // just in case something goes wrong in SF, return to the
2449                // called after a few seconds.
2450                ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!");
2451                mTransactionPending = false;
2452                break;
2453            }
2454        }
2455    }
2456}
2457
2458uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s)
2459{
2460    ssize_t dpyIdx = mCurrentState.displays.indexOfKey(s.token);
2461    if (dpyIdx < 0)
2462        return 0;
2463
2464    uint32_t flags = 0;
2465    DisplayDeviceState& disp(mCurrentState.displays.editValueAt(dpyIdx));
2466    if (disp.isValid()) {
2467        const uint32_t what = s.what;
2468        if (what & DisplayState::eSurfaceChanged) {
2469            if (IInterface::asBinder(disp.surface) != IInterface::asBinder(s.surface)) {
2470                disp.surface = s.surface;
2471                flags |= eDisplayTransactionNeeded;
2472            }
2473        }
2474        if (what & DisplayState::eLayerStackChanged) {
2475            if (disp.layerStack != s.layerStack) {
2476                disp.layerStack = s.layerStack;
2477                flags |= eDisplayTransactionNeeded;
2478            }
2479        }
2480        if (what & DisplayState::eDisplayProjectionChanged) {
2481            if (disp.orientation != s.orientation) {
2482                disp.orientation = s.orientation;
2483                flags |= eDisplayTransactionNeeded;
2484            }
2485            if (disp.frame != s.frame) {
2486                disp.frame = s.frame;
2487                flags |= eDisplayTransactionNeeded;
2488            }
2489            if (disp.viewport != s.viewport) {
2490                disp.viewport = s.viewport;
2491                flags |= eDisplayTransactionNeeded;
2492            }
2493        }
2494        if (what & DisplayState::eDisplaySizeChanged) {
2495            if (disp.width != s.width) {
2496                disp.width = s.width;
2497                flags |= eDisplayTransactionNeeded;
2498            }
2499            if (disp.height != s.height) {
2500                disp.height = s.height;
2501                flags |= eDisplayTransactionNeeded;
2502            }
2503        }
2504    }
2505    return flags;
2506}
2507
2508uint32_t SurfaceFlinger::setClientStateLocked(
2509        const sp<Client>& client,
2510        const layer_state_t& s)
2511{
2512    uint32_t flags = 0;
2513    sp<Layer> layer(client->getLayerUser(s.surface));
2514    if (layer != 0) {
2515        const uint32_t what = s.what;
2516        bool geometryAppliesWithResize =
2517                what & layer_state_t::eGeometryAppliesWithResize;
2518        if (what & layer_state_t::ePositionChanged) {
2519            if (layer->setPosition(s.x, s.y, !geometryAppliesWithResize)) {
2520                flags |= eTraversalNeeded;
2521            }
2522        }
2523        if (what & layer_state_t::eLayerChanged) {
2524            // NOTE: index needs to be calculated before we update the state
2525            const auto& p = layer->getParent();
2526            if (p == nullptr) {
2527                ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
2528                if (layer->setLayer(s.z) && idx >= 0) {
2529                    mCurrentState.layersSortedByZ.removeAt(idx);
2530                    mCurrentState.layersSortedByZ.add(layer);
2531                    // we need traversal (state changed)
2532                    // AND transaction (list changed)
2533                    flags |= eTransactionNeeded|eTraversalNeeded;
2534                }
2535            } else {
2536                if (p->setChildLayer(layer, s.z)) {
2537                    flags |= eTransactionNeeded|eTraversalNeeded;
2538                }
2539            }
2540        }
2541        if (what & layer_state_t::eSizeChanged) {
2542            if (layer->setSize(s.w, s.h)) {
2543                flags |= eTraversalNeeded;
2544            }
2545        }
2546        if (what & layer_state_t::eAlphaChanged) {
2547            if (layer->setAlpha(uint8_t(255.0f*s.alpha+0.5f)))
2548                flags |= eTraversalNeeded;
2549        }
2550        if (what & layer_state_t::eMatrixChanged) {
2551            if (layer->setMatrix(s.matrix))
2552                flags |= eTraversalNeeded;
2553        }
2554        if (what & layer_state_t::eTransparentRegionChanged) {
2555            if (layer->setTransparentRegionHint(s.transparentRegion))
2556                flags |= eTraversalNeeded;
2557        }
2558        if (what & layer_state_t::eFlagsChanged) {
2559            if (layer->setFlags(s.flags, s.mask))
2560                flags |= eTraversalNeeded;
2561        }
2562        if (what & layer_state_t::eCropChanged) {
2563            if (layer->setCrop(s.crop, !geometryAppliesWithResize))
2564                flags |= eTraversalNeeded;
2565        }
2566        if (what & layer_state_t::eFinalCropChanged) {
2567            if (layer->setFinalCrop(s.finalCrop))
2568                flags |= eTraversalNeeded;
2569        }
2570        if (what & layer_state_t::eLayerStackChanged) {
2571            ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
2572            // We only allow setting layer stacks for top level layers,
2573            // everything else inherits layer stack from its parent.
2574            if (layer->hasParent()) {
2575                ALOGE("Attempt to set layer stack on layer with parent (%s) is invalid",
2576                        layer->getName().string());
2577            } else if (idx < 0) {
2578                ALOGE("Attempt to set layer stack on layer without parent (%s) that "
2579                        "that also does not appear in the top level layer list. Something"
2580                        " has gone wrong.", layer->getName().string());
2581            } else if (layer->setLayerStack(s.layerStack)) {
2582                mCurrentState.layersSortedByZ.removeAt(idx);
2583                mCurrentState.layersSortedByZ.add(layer);
2584                // we need traversal (state changed)
2585                // AND transaction (list changed)
2586                flags |= eTransactionNeeded|eTraversalNeeded;
2587            }
2588        }
2589        if (what & layer_state_t::eDeferTransaction) {
2590            if (s.barrierHandle != nullptr) {
2591                layer->deferTransactionUntil(s.barrierHandle, s.frameNumber);
2592            } else if (s.barrierGbp != nullptr) {
2593                const sp<IGraphicBufferProducer>& gbp = s.barrierGbp;
2594                if (authenticateSurfaceTextureLocked(gbp)) {
2595                    const auto& otherLayer =
2596                        (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
2597                    layer->deferTransactionUntil(otherLayer, s.frameNumber);
2598                } else {
2599                    ALOGE("Attempt to defer transaction to to an"
2600                            " unrecognized GraphicBufferProducer");
2601                }
2602            }
2603            // We don't trigger a traversal here because if no other state is
2604            // changed, we don't want this to cause any more work
2605        }
2606        if (what & layer_state_t::eReparentChildren) {
2607            if (layer->reparentChildren(s.reparentHandle)) {
2608                flags |= eTransactionNeeded|eTraversalNeeded;
2609            }
2610        }
2611        if (what & layer_state_t::eDetachChildren) {
2612            layer->detachChildren();
2613        }
2614        if (what & layer_state_t::eOverrideScalingModeChanged) {
2615            layer->setOverrideScalingMode(s.overrideScalingMode);
2616            // We don't trigger a traversal here because if no other state is
2617            // changed, we don't want this to cause any more work
2618        }
2619    }
2620    return flags;
2621}
2622
2623status_t SurfaceFlinger::createLayer(
2624        const String8& name,
2625        const sp<Client>& client,
2626        uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
2627        uint32_t windowType, uint32_t ownerUid, sp<IBinder>* handle,
2628        sp<IGraphicBufferProducer>* gbp, sp<Layer>* parent)
2629{
2630    if (int32_t(w|h) < 0) {
2631        ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
2632                int(w), int(h));
2633        return BAD_VALUE;
2634    }
2635
2636    status_t result = NO_ERROR;
2637
2638    sp<Layer> layer;
2639
2640    switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
2641        case ISurfaceComposerClient::eFXSurfaceNormal:
2642            result = createNormalLayer(client,
2643                    name, w, h, flags, format,
2644                    handle, gbp, &layer);
2645            break;
2646        case ISurfaceComposerClient::eFXSurfaceDim:
2647            result = createDimLayer(client,
2648                    name, w, h, flags,
2649                    handle, gbp, &layer);
2650            break;
2651        default:
2652            result = BAD_VALUE;
2653            break;
2654    }
2655
2656    if (result != NO_ERROR) {
2657        return result;
2658    }
2659
2660    layer->setInfo(windowType, ownerUid);
2661
2662    result = addClientLayer(client, *handle, *gbp, layer, *parent);
2663    if (result != NO_ERROR) {
2664        return result;
2665    }
2666    mInterceptor.saveSurfaceCreation(layer);
2667
2668    setTransactionFlags(eTransactionNeeded);
2669    return result;
2670}
2671
2672status_t SurfaceFlinger::createNormalLayer(const sp<Client>& client,
2673        const String8& name, uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
2674        sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
2675{
2676    // initialize the surfaces
2677    switch (format) {
2678    case PIXEL_FORMAT_TRANSPARENT:
2679    case PIXEL_FORMAT_TRANSLUCENT:
2680        format = PIXEL_FORMAT_RGBA_8888;
2681        break;
2682    case PIXEL_FORMAT_OPAQUE:
2683        format = PIXEL_FORMAT_RGBX_8888;
2684        break;
2685    }
2686
2687    *outLayer = new Layer(this, client, name, w, h, flags);
2688    status_t err = (*outLayer)->setBuffers(w, h, format, flags);
2689    if (err == NO_ERROR) {
2690        *handle = (*outLayer)->getHandle();
2691        *gbp = (*outLayer)->getProducer();
2692    }
2693
2694    ALOGE_IF(err, "createNormalLayer() failed (%s)", strerror(-err));
2695    return err;
2696}
2697
2698status_t SurfaceFlinger::createDimLayer(const sp<Client>& client,
2699        const String8& name, uint32_t w, uint32_t h, uint32_t flags,
2700        sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
2701{
2702    *outLayer = new LayerDim(this, client, name, w, h, flags);
2703    *handle = (*outLayer)->getHandle();
2704    *gbp = (*outLayer)->getProducer();
2705    return NO_ERROR;
2706}
2707
2708status_t SurfaceFlinger::onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle)
2709{
2710    // called by a client when it wants to remove a Layer
2711    status_t err = NO_ERROR;
2712    sp<Layer> l(client->getLayerUser(handle));
2713    if (l != NULL) {
2714        mInterceptor.saveSurfaceDeletion(l);
2715        err = removeLayer(l);
2716        ALOGE_IF(err<0 && err != NAME_NOT_FOUND,
2717                "error removing layer=%p (%s)", l.get(), strerror(-err));
2718    }
2719    return err;
2720}
2721
2722status_t SurfaceFlinger::onLayerDestroyed(const wp<Layer>& layer)
2723{
2724    // called by ~LayerCleaner() when all references to the IBinder (handle)
2725    // are gone
2726    sp<Layer> l = layer.promote();
2727    if (l == nullptr) {
2728        // The layer has already been removed, carry on
2729        return NO_ERROR;
2730    } if (l->getParent() != nullptr) {
2731        // If we have a parent, then we can continue to live as long as it does.
2732        return NO_ERROR;
2733    }
2734    return removeLayer(l);
2735}
2736
2737// ---------------------------------------------------------------------------
2738
2739void SurfaceFlinger::onInitializeDisplays() {
2740    // reset screen orientation and use primary layer stack
2741    Vector<ComposerState> state;
2742    Vector<DisplayState> displays;
2743    DisplayState d;
2744    d.what = DisplayState::eDisplayProjectionChanged |
2745             DisplayState::eLayerStackChanged;
2746    d.token = mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY];
2747    d.layerStack = 0;
2748    d.orientation = DisplayState::eOrientationDefault;
2749    d.frame.makeInvalid();
2750    d.viewport.makeInvalid();
2751    d.width = 0;
2752    d.height = 0;
2753    displays.add(d);
2754    setTransactionState(state, displays, 0);
2755    setPowerModeInternal(getDisplayDevice(d.token), HWC_POWER_MODE_NORMAL);
2756
2757    const nsecs_t period =
2758            getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
2759    mAnimFrameTracker.setDisplayRefreshPeriod(period);
2760
2761    // Use phase of 0 since phase is not known.
2762    // Use latency of 0, which will snap to the ideal latency.
2763    setCompositorTimingSnapped(0, period, 0);
2764}
2765
2766void SurfaceFlinger::initializeDisplays() {
2767    class MessageScreenInitialized : public MessageBase {
2768        SurfaceFlinger* flinger;
2769    public:
2770        explicit MessageScreenInitialized(SurfaceFlinger* flinger) : flinger(flinger) { }
2771        virtual bool handler() {
2772            flinger->onInitializeDisplays();
2773            return true;
2774        }
2775    };
2776    sp<MessageBase> msg = new MessageScreenInitialized(this);
2777    postMessageAsync(msg);  // we may be called from main thread, use async message
2778}
2779
2780void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& hw,
2781        int mode) {
2782    ALOGD("Set power mode=%d, type=%d flinger=%p", mode, hw->getDisplayType(),
2783            this);
2784    int32_t type = hw->getDisplayType();
2785    int currentMode = hw->getPowerMode();
2786
2787    if (mode == currentMode) {
2788        ALOGD("Screen type=%d is already mode=%d", hw->getDisplayType(), mode);
2789        return;
2790    }
2791
2792    hw->setPowerMode(mode);
2793    if (type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
2794        ALOGW("Trying to set power mode for virtual display");
2795        return;
2796    }
2797
2798    if (mInterceptor.isEnabled()) {
2799        Mutex::Autolock _l(mStateLock);
2800        ssize_t idx = mCurrentState.displays.indexOfKey(hw->getDisplayToken());
2801        if (idx < 0) {
2802            ALOGW("Surface Interceptor SavePowerMode: invalid display token");
2803            return;
2804        }
2805        mInterceptor.savePowerModeUpdate(mCurrentState.displays.valueAt(idx).displayId, mode);
2806    }
2807
2808    if (currentMode == HWC_POWER_MODE_OFF) {
2809        // Turn on the display
2810        getHwComposer().setPowerMode(type, mode);
2811        if (type == DisplayDevice::DISPLAY_PRIMARY) {
2812            // FIXME: eventthread only knows about the main display right now
2813            mEventThread->onScreenAcquired();
2814            resyncToHardwareVsync(true);
2815        }
2816
2817        mVisibleRegionsDirty = true;
2818        mHasPoweredOff = true;
2819        repaintEverything();
2820
2821        struct sched_param param = {0};
2822        param.sched_priority = 1;
2823        if (sched_setscheduler(0, SCHED_FIFO, &param) != 0) {
2824            ALOGW("Couldn't set SCHED_FIFO on display on");
2825        }
2826    } else if (mode == HWC_POWER_MODE_OFF) {
2827        // Turn off the display
2828        struct sched_param param = {0};
2829        if (sched_setscheduler(0, SCHED_OTHER, &param) != 0) {
2830            ALOGW("Couldn't set SCHED_OTHER on display off");
2831        }
2832
2833        if (type == DisplayDevice::DISPLAY_PRIMARY) {
2834            disableHardwareVsync(true); // also cancels any in-progress resync
2835
2836            // FIXME: eventthread only knows about the main display right now
2837            mEventThread->onScreenReleased();
2838        }
2839
2840        getHwComposer().setPowerMode(type, mode);
2841        mVisibleRegionsDirty = true;
2842        // from this point on, SF will stop drawing on this display
2843    } else {
2844        getHwComposer().setPowerMode(type, mode);
2845    }
2846}
2847
2848void SurfaceFlinger::setPowerMode(const sp<IBinder>& display, int mode) {
2849    class MessageSetPowerMode: public MessageBase {
2850        SurfaceFlinger& mFlinger;
2851        sp<IBinder> mDisplay;
2852        int mMode;
2853    public:
2854        MessageSetPowerMode(SurfaceFlinger& flinger,
2855                const sp<IBinder>& disp, int mode) : mFlinger(flinger),
2856                    mDisplay(disp) { mMode = mode; }
2857        virtual bool handler() {
2858            sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay));
2859            if (hw == NULL) {
2860                ALOGE("Attempt to set power mode = %d for null display %p",
2861                        mMode, mDisplay.get());
2862            } else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) {
2863                ALOGW("Attempt to set power mode = %d for virtual display",
2864                        mMode);
2865            } else {
2866                mFlinger.setPowerModeInternal(hw, mMode);
2867            }
2868            return true;
2869        }
2870    };
2871    sp<MessageBase> msg = new MessageSetPowerMode(*this, display, mode);
2872    postMessageSync(msg);
2873}
2874
2875// ---------------------------------------------------------------------------
2876
2877status_t SurfaceFlinger::dump(int fd, const Vector<String16>& args)
2878{
2879    String8 result;
2880
2881    IPCThreadState* ipc = IPCThreadState::self();
2882    const int pid = ipc->getCallingPid();
2883    const int uid = ipc->getCallingUid();
2884    if ((uid != AID_SHELL) &&
2885            !PermissionCache::checkPermission(sDump, pid, uid)) {
2886        result.appendFormat("Permission Denial: "
2887                "can't dump SurfaceFlinger from pid=%d, uid=%d\n", pid, uid);
2888    } else {
2889        // Try to get the main lock, but give up after one second
2890        // (this would indicate SF is stuck, but we want to be able to
2891        // print something in dumpsys).
2892        status_t err = mStateLock.timedLock(s2ns(1));
2893        bool locked = (err == NO_ERROR);
2894        if (!locked) {
2895            result.appendFormat(
2896                    "SurfaceFlinger appears to be unresponsive (%s [%d]), "
2897                    "dumping anyways (no locks held)\n", strerror(-err), err);
2898        }
2899
2900        bool dumpAll = true;
2901        size_t index = 0;
2902        size_t numArgs = args.size();
2903        if (numArgs) {
2904            if ((index < numArgs) &&
2905                    (args[index] == String16("--list"))) {
2906                index++;
2907                listLayersLocked(args, index, result);
2908                dumpAll = false;
2909            }
2910
2911            if ((index < numArgs) &&
2912                    (args[index] == String16("--latency"))) {
2913                index++;
2914                dumpStatsLocked(args, index, result);
2915                dumpAll = false;
2916            }
2917
2918            if ((index < numArgs) &&
2919                    (args[index] == String16("--latency-clear"))) {
2920                index++;
2921                clearStatsLocked(args, index, result);
2922                dumpAll = false;
2923            }
2924
2925            if ((index < numArgs) &&
2926                    (args[index] == String16("--dispsync"))) {
2927                index++;
2928                mPrimaryDispSync.dump(result);
2929                dumpAll = false;
2930            }
2931
2932            if ((index < numArgs) &&
2933                    (args[index] == String16("--static-screen"))) {
2934                index++;
2935                dumpStaticScreenStats(result);
2936                dumpAll = false;
2937            }
2938
2939            if ((index < numArgs) &&
2940                    (args[index] == String16("--frame-events"))) {
2941                index++;
2942                dumpFrameEventsLocked(result);
2943                dumpAll = false;
2944            }
2945        }
2946
2947        if (dumpAll) {
2948            dumpAllLocked(args, index, result);
2949        }
2950
2951        if (locked) {
2952            mStateLock.unlock();
2953        }
2954    }
2955    write(fd, result.string(), result.size());
2956    return NO_ERROR;
2957}
2958
2959void SurfaceFlinger::listLayersLocked(const Vector<String16>& /* args */,
2960        size_t& /* index */, String8& result) const
2961{
2962    mCurrentState.traverseInZOrder([&](Layer* layer) {
2963        result.appendFormat("%s\n", layer->getName().string());
2964    });
2965}
2966
2967void SurfaceFlinger::dumpStatsLocked(const Vector<String16>& args, size_t& index,
2968        String8& result) const
2969{
2970    String8 name;
2971    if (index < args.size()) {
2972        name = String8(args[index]);
2973        index++;
2974    }
2975
2976    const nsecs_t period =
2977            getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
2978    result.appendFormat("%" PRId64 "\n", period);
2979
2980    if (name.isEmpty()) {
2981        mAnimFrameTracker.dumpStats(result);
2982    } else {
2983        mCurrentState.traverseInZOrder([&](Layer* layer) {
2984            if (name == layer->getName()) {
2985                layer->dumpFrameStats(result);
2986            }
2987        });
2988    }
2989}
2990
2991void SurfaceFlinger::clearStatsLocked(const Vector<String16>& args, size_t& index,
2992        String8& /* result */)
2993{
2994    String8 name;
2995    if (index < args.size()) {
2996        name = String8(args[index]);
2997        index++;
2998    }
2999
3000    mCurrentState.traverseInZOrder([&](Layer* layer) {
3001        if (name.isEmpty() || (name == layer->getName())) {
3002            layer->clearFrameStats();
3003        }
3004    });
3005
3006    mAnimFrameTracker.clearStats();
3007}
3008
3009// This should only be called from the main thread.  Otherwise it would need
3010// the lock and should use mCurrentState rather than mDrawingState.
3011void SurfaceFlinger::logFrameStats() {
3012    mDrawingState.traverseInZOrder([&](Layer* layer) {
3013        layer->logFrameStats();
3014    });
3015
3016    mAnimFrameTracker.logAndResetStats(String8("<win-anim>"));
3017}
3018
3019void SurfaceFlinger::appendSfConfigString(String8& result) const
3020{
3021    result.append(" [sf");
3022    result.appendFormat(" HAS_CONTEXT_PRIORITY=%d", useContextPriority);
3023
3024    if (isLayerTripleBufferingDisabled())
3025        result.append(" DISABLE_TRIPLE_BUFFERING");
3026
3027    result.appendFormat(" PRESENT_TIME_OFFSET=%" PRId64, dispSyncPresentTimeOffset);
3028    result.appendFormat(" FORCE_HWC_FOR_RBG_TO_YUV=%d", useHwcForRgbToYuv);
3029    result.appendFormat(" MAX_VIRT_DISPLAY_DIM=%" PRIu64, maxVirtualDisplaySize);
3030    result.appendFormat(" RUNNING_WITHOUT_SYNC_FRAMEWORK=%d", !hasSyncFramework);
3031    result.appendFormat(" NUM_FRAMEBUFFER_SURFACE_BUFFERS=%" PRId64,
3032                        maxFrameBufferAcquiredBuffers);
3033    result.append("]");
3034}
3035
3036void SurfaceFlinger::dumpStaticScreenStats(String8& result) const
3037{
3038    result.appendFormat("Static screen stats:\n");
3039    for (size_t b = 0; b < NUM_BUCKETS - 1; ++b) {
3040        float bucketTimeSec = mFrameBuckets[b] / 1e9;
3041        float percent = 100.0f *
3042                static_cast<float>(mFrameBuckets[b]) / mTotalTime;
3043        result.appendFormat("  < %zd frames: %.3f s (%.1f%%)\n",
3044                b + 1, bucketTimeSec, percent);
3045    }
3046    float bucketTimeSec = mFrameBuckets[NUM_BUCKETS - 1] / 1e9;
3047    float percent = 100.0f *
3048            static_cast<float>(mFrameBuckets[NUM_BUCKETS - 1]) / mTotalTime;
3049    result.appendFormat("  %zd+ frames: %.3f s (%.1f%%)\n",
3050            NUM_BUCKETS - 1, bucketTimeSec, percent);
3051}
3052
3053void SurfaceFlinger::dumpFrameEventsLocked(String8& result) {
3054    result.appendFormat("Layer frame timestamps:\n");
3055
3056    const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
3057    const size_t count = currentLayers.size();
3058    for (size_t i=0 ; i<count ; i++) {
3059        currentLayers[i]->dumpFrameEvents(result);
3060    }
3061}
3062
3063void SurfaceFlinger::recordBufferingStats(const char* layerName,
3064        std::vector<OccupancyTracker::Segment>&& history) {
3065    Mutex::Autolock lock(mBufferingStatsMutex);
3066    auto& stats = mBufferingStats[layerName];
3067    for (const auto& segment : history) {
3068        if (!segment.usedThirdBuffer) {
3069            stats.twoBufferTime += segment.totalTime;
3070        }
3071        if (segment.occupancyAverage < 1.0f) {
3072            stats.doubleBufferedTime += segment.totalTime;
3073        } else if (segment.occupancyAverage < 2.0f) {
3074            stats.tripleBufferedTime += segment.totalTime;
3075        }
3076        ++stats.numSegments;
3077        stats.totalTime += segment.totalTime;
3078    }
3079}
3080
3081void SurfaceFlinger::dumpBufferingStats(String8& result) const {
3082    result.append("Buffering stats:\n");
3083    result.append("  [Layer name] <Active time> <Two buffer> "
3084            "<Double buffered> <Triple buffered>\n");
3085    Mutex::Autolock lock(mBufferingStatsMutex);
3086    typedef std::tuple<std::string, float, float, float> BufferTuple;
3087    std::map<float, BufferTuple, std::greater<float>> sorted;
3088    for (const auto& statsPair : mBufferingStats) {
3089        const char* name = statsPair.first.c_str();
3090        const BufferingStats& stats = statsPair.second;
3091        if (stats.numSegments == 0) {
3092            continue;
3093        }
3094        float activeTime = ns2ms(stats.totalTime) / 1000.0f;
3095        float twoBufferRatio = static_cast<float>(stats.twoBufferTime) /
3096                stats.totalTime;
3097        float doubleBufferRatio = static_cast<float>(
3098                stats.doubleBufferedTime) / stats.totalTime;
3099        float tripleBufferRatio = static_cast<float>(
3100                stats.tripleBufferedTime) / stats.totalTime;
3101        sorted.insert({activeTime, {name, twoBufferRatio,
3102                doubleBufferRatio, tripleBufferRatio}});
3103    }
3104    for (const auto& sortedPair : sorted) {
3105        float activeTime = sortedPair.first;
3106        const BufferTuple& values = sortedPair.second;
3107        result.appendFormat("  [%s] %.2f %.3f %.3f %.3f\n",
3108                std::get<0>(values).c_str(), activeTime,
3109                std::get<1>(values), std::get<2>(values),
3110                std::get<3>(values));
3111    }
3112    result.append("\n");
3113}
3114
3115void SurfaceFlinger::dumpAllLocked(const Vector<String16>& args, size_t& index,
3116        String8& result) const
3117{
3118    bool colorize = false;
3119    if (index < args.size()
3120            && (args[index] == String16("--color"))) {
3121        colorize = true;
3122        index++;
3123    }
3124
3125    Colorizer colorizer(colorize);
3126
3127    // figure out if we're stuck somewhere
3128    const nsecs_t now = systemTime();
3129    const nsecs_t inSwapBuffers(mDebugInSwapBuffers);
3130    const nsecs_t inTransaction(mDebugInTransaction);
3131    nsecs_t inSwapBuffersDuration = (inSwapBuffers) ? now-inSwapBuffers : 0;
3132    nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
3133
3134    /*
3135     * Dump library configuration.
3136     */
3137
3138    colorizer.bold(result);
3139    result.append("Build configuration:");
3140    colorizer.reset(result);
3141    appendSfConfigString(result);
3142    appendUiConfigString(result);
3143    appendGuiConfigString(result);
3144    result.append("\n");
3145
3146    colorizer.bold(result);
3147    result.append("Sync configuration: ");
3148    colorizer.reset(result);
3149    result.append(SyncFeatures::getInstance().toString());
3150    result.append("\n");
3151
3152    colorizer.bold(result);
3153    result.append("DispSync configuration: ");
3154    colorizer.reset(result);
3155    result.appendFormat("app phase %" PRId64 " ns, sf phase %" PRId64 " ns, "
3156            "present offset %" PRId64 " ns (refresh %" PRId64 " ns)",
3157        vsyncPhaseOffsetNs, sfVsyncPhaseOffsetNs, dispSyncPresentTimeOffset,
3158        mHwc->getRefreshPeriod(HWC_DISPLAY_PRIMARY));
3159    result.append("\n");
3160
3161    // Dump static screen stats
3162    result.append("\n");
3163    dumpStaticScreenStats(result);
3164    result.append("\n");
3165
3166    dumpBufferingStats(result);
3167
3168    /*
3169     * Dump the visible layer list
3170     */
3171    colorizer.bold(result);
3172    result.appendFormat("Visible layers (count = %zu)\n", mNumLayers);
3173    colorizer.reset(result);
3174    mCurrentState.traverseInZOrder([&](Layer* layer) {
3175        layer->dump(result, colorizer);
3176    });
3177
3178    /*
3179     * Dump Display state
3180     */
3181
3182    colorizer.bold(result);
3183    result.appendFormat("Displays (%zu entries)\n", mDisplays.size());
3184    colorizer.reset(result);
3185    for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
3186        const sp<const DisplayDevice>& hw(mDisplays[dpy]);
3187        hw->dump(result);
3188    }
3189
3190    /*
3191     * Dump SurfaceFlinger global state
3192     */
3193
3194    colorizer.bold(result);
3195    result.append("SurfaceFlinger global state:\n");
3196    colorizer.reset(result);
3197
3198    HWComposer& hwc(getHwComposer());
3199    sp<const DisplayDevice> hw(getDefaultDisplayDevice());
3200
3201    colorizer.bold(result);
3202    result.appendFormat("EGL implementation : %s\n",
3203            eglQueryStringImplementationANDROID(mEGLDisplay, EGL_VERSION));
3204    colorizer.reset(result);
3205    result.appendFormat("%s\n",
3206            eglQueryStringImplementationANDROID(mEGLDisplay, EGL_EXTENSIONS));
3207
3208    mRenderEngine->dump(result);
3209
3210    hw->undefinedRegion.dump(result, "undefinedRegion");
3211    result.appendFormat("  orientation=%d, isDisplayOn=%d\n",
3212            hw->getOrientation(), hw->isDisplayOn());
3213    result.appendFormat(
3214            "  last eglSwapBuffers() time: %f us\n"
3215            "  last transaction time     : %f us\n"
3216            "  transaction-flags         : %08x\n"
3217            "  refresh-rate              : %f fps\n"
3218            "  x-dpi                     : %f\n"
3219            "  y-dpi                     : %f\n"
3220            "  gpu_to_cpu_unsupported    : %d\n"
3221            ,
3222            mLastSwapBufferTime/1000.0,
3223            mLastTransactionTime/1000.0,
3224            mTransactionFlags,
3225            1e9 / hwc.getRefreshPeriod(HWC_DISPLAY_PRIMARY),
3226            hwc.getDpiX(HWC_DISPLAY_PRIMARY),
3227            hwc.getDpiY(HWC_DISPLAY_PRIMARY),
3228            !mGpuToCpuSupported);
3229
3230    result.appendFormat("  eglSwapBuffers time: %f us\n",
3231            inSwapBuffersDuration/1000.0);
3232
3233    result.appendFormat("  transaction time: %f us\n",
3234            inTransactionDuration/1000.0);
3235
3236    /*
3237     * VSYNC state
3238     */
3239    mEventThread->dump(result);
3240
3241    /*
3242     * Dump HWComposer state
3243     */
3244    colorizer.bold(result);
3245    result.append("h/w composer state:\n");
3246    colorizer.reset(result);
3247    result.appendFormat("  h/w composer %s and %s\n",
3248            hwc.initCheck()==NO_ERROR ? "present" : "not present",
3249                    (mDebugDisableHWC || mDebugRegion || mDaltonize
3250                            || mHasColorMatrix) ? "disabled" : "enabled");
3251    hwc.dump(result);
3252
3253    /*
3254     * Dump gralloc state
3255     */
3256    const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
3257    alloc.dump(result);
3258}
3259
3260const Vector< sp<Layer> >&
3261SurfaceFlinger::getLayerSortedByZForHwcDisplay(int id) {
3262    // Note: mStateLock is held here
3263    wp<IBinder> dpy;
3264    for (size_t i=0 ; i<mDisplays.size() ; i++) {
3265        if (mDisplays.valueAt(i)->getHwcDisplayId() == id) {
3266            dpy = mDisplays.keyAt(i);
3267            break;
3268        }
3269    }
3270    if (dpy == NULL) {
3271        ALOGE("getLayerSortedByZForHwcDisplay: invalid hwc display id %d", id);
3272        // Just use the primary display so we have something to return
3273        dpy = getBuiltInDisplay(DisplayDevice::DISPLAY_PRIMARY);
3274    }
3275    return getDisplayDevice(dpy)->getVisibleLayersSortedByZ();
3276}
3277
3278bool SurfaceFlinger::startDdmConnection()
3279{
3280    void* libddmconnection_dso =
3281            dlopen("libsurfaceflinger_ddmconnection.so", RTLD_NOW);
3282    if (!libddmconnection_dso) {
3283        return false;
3284    }
3285    void (*DdmConnection_start)(const char* name);
3286    DdmConnection_start =
3287            (decltype(DdmConnection_start))dlsym(libddmconnection_dso, "DdmConnection_start");
3288    if (!DdmConnection_start) {
3289        dlclose(libddmconnection_dso);
3290        return false;
3291    }
3292    (*DdmConnection_start)(getServiceName());
3293    return true;
3294}
3295
3296status_t SurfaceFlinger::onTransact(
3297    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
3298{
3299    switch (code) {
3300        case CREATE_CONNECTION:
3301        case CREATE_DISPLAY:
3302        case BOOT_FINISHED:
3303        case CLEAR_ANIMATION_FRAME_STATS:
3304        case GET_ANIMATION_FRAME_STATS:
3305        case SET_POWER_MODE:
3306        case GET_HDR_CAPABILITIES:
3307        {
3308            // codes that require permission check
3309            IPCThreadState* ipc = IPCThreadState::self();
3310            const int pid = ipc->getCallingPid();
3311            const int uid = ipc->getCallingUid();
3312            if ((uid != AID_GRAPHICS && uid != AID_SYSTEM) &&
3313                    !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)) {
3314                ALOGE("Permission Denial: "
3315                        "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
3316                return PERMISSION_DENIED;
3317            }
3318            break;
3319        }
3320        /*
3321         * Calling setTransactionState is safe, because you need to have been
3322         * granted a reference to Client* and Handle* to do anything with it.
3323         *
3324         * Creating a scoped connection is safe, as per discussion in ISurfaceComposer.h
3325         */
3326        case SET_TRANSACTION_STATE:
3327        case CREATE_SCOPED_CONNECTION:
3328        {
3329            break;
3330        }
3331        case CAPTURE_SCREEN:
3332        {
3333            // codes that require permission check
3334            IPCThreadState* ipc = IPCThreadState::self();
3335            const int pid = ipc->getCallingPid();
3336            const int uid = ipc->getCallingUid();
3337            if ((uid != AID_GRAPHICS) &&
3338                    !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
3339                ALOGE("Permission Denial: "
3340                        "can't read framebuffer pid=%d, uid=%d", pid, uid);
3341                return PERMISSION_DENIED;
3342            }
3343            break;
3344        }
3345    }
3346
3347    status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
3348    if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
3349        CHECK_INTERFACE(ISurfaceComposer, data, reply);
3350        if (CC_UNLIKELY(!PermissionCache::checkCallingPermission(sHardwareTest))) {
3351            IPCThreadState* ipc = IPCThreadState::self();
3352            const int pid = ipc->getCallingPid();
3353            const int uid = ipc->getCallingUid();
3354            ALOGE("Permission Denial: "
3355                    "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
3356            return PERMISSION_DENIED;
3357        }
3358        int n;
3359        switch (code) {
3360            case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
3361            case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE
3362                return NO_ERROR;
3363            case 1002:  // SHOW_UPDATES
3364                n = data.readInt32();
3365                mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
3366                invalidateHwcGeometry();
3367                repaintEverything();
3368                return NO_ERROR;
3369            case 1004:{ // repaint everything
3370                repaintEverything();
3371                return NO_ERROR;
3372            }
3373            case 1005:{ // force transaction
3374                setTransactionFlags(
3375                        eTransactionNeeded|
3376                        eDisplayTransactionNeeded|
3377                        eTraversalNeeded);
3378                return NO_ERROR;
3379            }
3380            case 1006:{ // send empty update
3381                signalRefresh();
3382                return NO_ERROR;
3383            }
3384            case 1008:  // toggle use of hw composer
3385                n = data.readInt32();
3386                mDebugDisableHWC = n ? 1 : 0;
3387                invalidateHwcGeometry();
3388                repaintEverything();
3389                return NO_ERROR;
3390            case 1009:  // toggle use of transform hint
3391                n = data.readInt32();
3392                mDebugDisableTransformHint = n ? 1 : 0;
3393                invalidateHwcGeometry();
3394                repaintEverything();
3395                return NO_ERROR;
3396            case 1010:  // interrogate.
3397                reply->writeInt32(0);
3398                reply->writeInt32(0);
3399                reply->writeInt32(mDebugRegion);
3400                reply->writeInt32(0);
3401                reply->writeInt32(mDebugDisableHWC);
3402                return NO_ERROR;
3403            case 1013: {
3404                Mutex::Autolock _l(mStateLock);
3405                sp<const DisplayDevice> hw(getDefaultDisplayDevice());
3406                reply->writeInt32(hw->getPageFlipCount());
3407                return NO_ERROR;
3408            }
3409            case 1014: {
3410                // daltonize
3411                n = data.readInt32();
3412                switch (n % 10) {
3413                    case 1:
3414                        mDaltonizer.setType(ColorBlindnessType::Protanomaly);
3415                        break;
3416                    case 2:
3417                        mDaltonizer.setType(ColorBlindnessType::Deuteranomaly);
3418                        break;
3419                    case 3:
3420                        mDaltonizer.setType(ColorBlindnessType::Tritanomaly);
3421                        break;
3422                }
3423                if (n >= 10) {
3424                    mDaltonizer.setMode(ColorBlindnessMode::Correction);
3425                } else {
3426                    mDaltonizer.setMode(ColorBlindnessMode::Simulation);
3427                }
3428                mDaltonize = n > 0;
3429                invalidateHwcGeometry();
3430                repaintEverything();
3431                return NO_ERROR;
3432            }
3433            case 1015: {
3434                // apply a color matrix
3435                n = data.readInt32();
3436                mHasColorMatrix = n ? 1 : 0;
3437                if (n) {
3438                    // color matrix is sent as mat3 matrix followed by vec3
3439                    // offset, then packed into a mat4 where the last row is
3440                    // the offset and extra values are 0
3441                    for (size_t i = 0 ; i < 4; i++) {
3442                      for (size_t j = 0; j < 4; j++) {
3443                          mColorMatrix[i][j] = data.readFloat();
3444                      }
3445                    }
3446                } else {
3447                    mColorMatrix = mat4();
3448                }
3449                invalidateHwcGeometry();
3450                repaintEverything();
3451                return NO_ERROR;
3452            }
3453            // This is an experimental interface
3454            // Needs to be shifted to proper binder interface when we productize
3455            case 1016: {
3456                n = data.readInt32();
3457                mPrimaryDispSync.setRefreshSkipCount(n);
3458                return NO_ERROR;
3459            }
3460            case 1017: {
3461                n = data.readInt32();
3462                mForceFullDamage = static_cast<bool>(n);
3463                return NO_ERROR;
3464            }
3465            case 1018: { // Modify Choreographer's phase offset
3466                n = data.readInt32();
3467                mEventThread->setPhaseOffset(static_cast<nsecs_t>(n));
3468                return NO_ERROR;
3469            }
3470            case 1019: { // Modify SurfaceFlinger's phase offset
3471                n = data.readInt32();
3472                mSFEventThread->setPhaseOffset(static_cast<nsecs_t>(n));
3473                return NO_ERROR;
3474            }
3475            case 1020: { // Layer updates interceptor
3476                n = data.readInt32();
3477                if (n) {
3478                    ALOGV("Interceptor enabled");
3479                    mInterceptor.enable(mDrawingState.layersSortedByZ, mDrawingState.displays);
3480                }
3481                else{
3482                    ALOGV("Interceptor disabled");
3483                    mInterceptor.disable();
3484                }
3485                return NO_ERROR;
3486            }
3487            case 1021: { // Disable HWC virtual displays
3488                n = data.readInt32();
3489                mUseHwcVirtualDisplays = !n;
3490                return NO_ERROR;
3491            }
3492        }
3493    }
3494    return err;
3495}
3496
3497void SurfaceFlinger::repaintEverything() {
3498    android_atomic_or(1, &mRepaintEverything);
3499    signalTransaction();
3500}
3501
3502// ---------------------------------------------------------------------------
3503// Capture screen into an IGraphiBufferProducer
3504// ---------------------------------------------------------------------------
3505
3506/* The code below is here to handle b/8734824
3507 *
3508 * We create a IGraphicBufferProducer wrapper that forwards all calls
3509 * from the surfaceflinger thread to the calling binder thread, where they
3510 * are executed. This allows the calling thread in the calling process to be
3511 * reused and not depend on having "enough" binder threads to handle the
3512 * requests.
3513 */
3514class GraphicProducerWrapper : public BBinder, public MessageHandler {
3515    /* Parts of GraphicProducerWrapper are run on two different threads,
3516     * communicating by sending messages via Looper but also by shared member
3517     * data. Coherence maintenance is subtle and in places implicit (ugh).
3518     *
3519     * Don't rely on Looper's sendMessage/handleMessage providing
3520     * release/acquire semantics for any data not actually in the Message.
3521     * Data going from surfaceflinger to binder threads needs to be
3522     * synchronized explicitly.
3523     *
3524     * Barrier open/wait do provide release/acquire semantics. This provides
3525     * implicit synchronization for data coming back from binder to
3526     * surfaceflinger threads.
3527     */
3528
3529    sp<IGraphicBufferProducer> impl;
3530    sp<Looper> looper;
3531    status_t result;
3532    bool exitPending;
3533    bool exitRequested;
3534    Barrier barrier;
3535    uint32_t code;
3536    Parcel const* data;
3537    Parcel* reply;
3538
3539    enum {
3540        MSG_API_CALL,
3541        MSG_EXIT
3542    };
3543
3544    /*
3545     * Called on surfaceflinger thread. This is called by our "fake"
3546     * BpGraphicBufferProducer. We package the data and reply Parcel and
3547     * forward them to the binder thread.
3548     */
3549    virtual status_t transact(uint32_t code,
3550            const Parcel& data, Parcel* reply, uint32_t /* flags */) {
3551        this->code = code;
3552        this->data = &data;
3553        this->reply = reply;
3554        if (exitPending) {
3555            // if we've exited, we run the message synchronously right here.
3556            // note (JH): as far as I can tell from looking at the code, this
3557            // never actually happens. if it does, i'm not sure if it happens
3558            // on the surfaceflinger or binder thread.
3559            handleMessage(Message(MSG_API_CALL));
3560        } else {
3561            barrier.close();
3562            // Prevent stores to this->{code, data, reply} from being
3563            // reordered later than the construction of Message.
3564            atomic_thread_fence(memory_order_release);
3565            looper->sendMessage(this, Message(MSG_API_CALL));
3566            barrier.wait();
3567        }
3568        return result;
3569    }
3570
3571    /*
3572     * here we run on the binder thread. All we've got to do is
3573     * call the real BpGraphicBufferProducer.
3574     */
3575    virtual void handleMessage(const Message& message) {
3576        int what = message.what;
3577        // Prevent reads below from happening before the read from Message
3578        atomic_thread_fence(memory_order_acquire);
3579        if (what == MSG_API_CALL) {
3580            result = IInterface::asBinder(impl)->transact(code, data[0], reply);
3581            barrier.open();
3582        } else if (what == MSG_EXIT) {
3583            exitRequested = true;
3584        }
3585    }
3586
3587public:
3588    explicit GraphicProducerWrapper(const sp<IGraphicBufferProducer>& impl)
3589    :   impl(impl),
3590        looper(new Looper(true)),
3591        result(NO_ERROR),
3592        exitPending(false),
3593        exitRequested(false),
3594        code(0),
3595        data(NULL),
3596        reply(NULL)
3597    {}
3598
3599    // Binder thread
3600    status_t waitForResponse() {
3601        do {
3602            looper->pollOnce(-1);
3603        } while (!exitRequested);
3604        return result;
3605    }
3606
3607    // Client thread
3608    void exit(status_t result) {
3609        this->result = result;
3610        exitPending = true;
3611        // Ensure this->result is visible to the binder thread before it
3612        // handles the message.
3613        atomic_thread_fence(memory_order_release);
3614        looper->sendMessage(this, Message(MSG_EXIT));
3615    }
3616};
3617
3618
3619status_t SurfaceFlinger::captureScreen(const sp<IBinder>& display,
3620        const sp<IGraphicBufferProducer>& producer,
3621        Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
3622        int32_t minLayerZ, int32_t maxLayerZ,
3623        bool useIdentityTransform, ISurfaceComposer::Rotation rotation) {
3624
3625    if (CC_UNLIKELY(display == 0))
3626        return BAD_VALUE;
3627
3628    if (CC_UNLIKELY(producer == 0))
3629        return BAD_VALUE;
3630
3631    // if we have secure windows on this display, never allow the screen capture
3632    // unless the producer interface is local (i.e.: we can take a screenshot for
3633    // ourselves).
3634    bool isLocalScreenshot = IInterface::asBinder(producer)->localBinder();
3635
3636    // Convert to surfaceflinger's internal rotation type.
3637    Transform::orientation_flags rotationFlags;
3638    switch (rotation) {
3639        case ISurfaceComposer::eRotateNone:
3640            rotationFlags = Transform::ROT_0;
3641            break;
3642        case ISurfaceComposer::eRotate90:
3643            rotationFlags = Transform::ROT_90;
3644            break;
3645        case ISurfaceComposer::eRotate180:
3646            rotationFlags = Transform::ROT_180;
3647            break;
3648        case ISurfaceComposer::eRotate270:
3649            rotationFlags = Transform::ROT_270;
3650            break;
3651        default:
3652            rotationFlags = Transform::ROT_0;
3653            ALOGE("Invalid rotation passed to captureScreen(): %d\n", rotation);
3654            break;
3655    }
3656
3657    class MessageCaptureScreen : public MessageBase {
3658        SurfaceFlinger* flinger;
3659        sp<IBinder> display;
3660        sp<IGraphicBufferProducer> producer;
3661        Rect sourceCrop;
3662        uint32_t reqWidth, reqHeight;
3663        int32_t minLayerZ,maxLayerZ;
3664        bool useIdentityTransform;
3665        Transform::orientation_flags rotation;
3666        status_t result;
3667        bool isLocalScreenshot;
3668    public:
3669        MessageCaptureScreen(SurfaceFlinger* flinger,
3670                const sp<IBinder>& display,
3671                const sp<IGraphicBufferProducer>& producer,
3672                Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
3673                int32_t minLayerZ, int32_t maxLayerZ,
3674                bool useIdentityTransform,
3675                Transform::orientation_flags rotation,
3676                bool isLocalScreenshot)
3677            : flinger(flinger), display(display), producer(producer),
3678              sourceCrop(sourceCrop), reqWidth(reqWidth), reqHeight(reqHeight),
3679              minLayerZ(minLayerZ), maxLayerZ(maxLayerZ),
3680              useIdentityTransform(useIdentityTransform),
3681              rotation(rotation), result(PERMISSION_DENIED),
3682              isLocalScreenshot(isLocalScreenshot)
3683        {
3684        }
3685        status_t getResult() const {
3686            return result;
3687        }
3688        virtual bool handler() {
3689            Mutex::Autolock _l(flinger->mStateLock);
3690            sp<const DisplayDevice> hw(flinger->getDisplayDevice(display));
3691            result = flinger->captureScreenImplLocked(hw, producer,
3692                    sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ,
3693                    useIdentityTransform, rotation, isLocalScreenshot);
3694            static_cast<GraphicProducerWrapper*>(IInterface::asBinder(producer).get())->exit(result);
3695            return true;
3696        }
3697    };
3698
3699    // this creates a "fake" BBinder which will serve as a "fake" remote
3700    // binder to receive the marshaled calls and forward them to the
3701    // real remote (a BpGraphicBufferProducer)
3702    sp<GraphicProducerWrapper> wrapper = new GraphicProducerWrapper(producer);
3703
3704    // the asInterface() call below creates our "fake" BpGraphicBufferProducer
3705    // which does the marshaling work forwards to our "fake remote" above.
3706    sp<MessageBase> msg = new MessageCaptureScreen(this,
3707            display, IGraphicBufferProducer::asInterface( wrapper ),
3708            sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ,
3709            useIdentityTransform, rotationFlags, isLocalScreenshot);
3710
3711    status_t res = postMessageAsync(msg);
3712    if (res == NO_ERROR) {
3713        res = wrapper->waitForResponse();
3714    }
3715    return res;
3716}
3717
3718
3719void SurfaceFlinger::renderScreenImplLocked(
3720        const sp<const DisplayDevice>& hw,
3721        Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
3722        int32_t minLayerZ, int32_t maxLayerZ,
3723        bool yswap, bool useIdentityTransform, Transform::orientation_flags rotation)
3724{
3725    ATRACE_CALL();
3726    RenderEngine& engine(getRenderEngine());
3727
3728    // get screen geometry
3729    const int32_t hw_w = hw->getWidth();
3730    const int32_t hw_h = hw->getHeight();
3731    const bool filtering = static_cast<int32_t>(reqWidth) != hw_w ||
3732                           static_cast<int32_t>(reqHeight) != hw_h;
3733
3734    // if a default or invalid sourceCrop is passed in, set reasonable values
3735    if (sourceCrop.width() == 0 || sourceCrop.height() == 0 ||
3736            !sourceCrop.isValid()) {
3737        sourceCrop.setLeftTop(Point(0, 0));
3738        sourceCrop.setRightBottom(Point(hw_w, hw_h));
3739    }
3740
3741    // ensure that sourceCrop is inside screen
3742    if (sourceCrop.left < 0) {
3743        ALOGE("Invalid crop rect: l = %d (< 0)", sourceCrop.left);
3744    }
3745    if (sourceCrop.right > hw_w) {
3746        ALOGE("Invalid crop rect: r = %d (> %d)", sourceCrop.right, hw_w);
3747    }
3748    if (sourceCrop.top < 0) {
3749        ALOGE("Invalid crop rect: t = %d (< 0)", sourceCrop.top);
3750    }
3751    if (sourceCrop.bottom > hw_h) {
3752        ALOGE("Invalid crop rect: b = %d (> %d)", sourceCrop.bottom, hw_h);
3753    }
3754
3755    // make sure to clear all GL error flags
3756    engine.checkErrors();
3757
3758    // set-up our viewport
3759    engine.setViewportAndProjection(
3760        reqWidth, reqHeight, sourceCrop, hw_h, yswap, rotation);
3761    engine.disableTexturing();
3762
3763    // redraw the screen entirely...
3764    engine.clearWithColor(0, 0, 0, 1);
3765
3766    // We loop through the first level of layers without traversing,
3767    // as we need to interpret min/max layer Z in the top level Z space.
3768    for (const auto& layer : mDrawingState.layersSortedByZ) {
3769        if (layer->getLayerStack() != hw->getLayerStack()) {
3770            continue;
3771        }
3772        const Layer::State& state(layer->getDrawingState());
3773        if (state.z < minLayerZ || state.z > maxLayerZ) {
3774            continue;
3775        }
3776        layer->traverseInZOrder([&](Layer* layer) {
3777            if (!layer->isVisible()) {
3778                return;
3779            }
3780            if (filtering) layer->setFiltering(true);
3781            layer->draw(hw, useIdentityTransform);
3782            if (filtering) layer->setFiltering(false);
3783        });
3784    }
3785
3786    // compositionComplete is needed for older driver
3787    hw->compositionComplete();
3788    hw->setViewportAndProjection();
3789}
3790
3791
3792status_t SurfaceFlinger::captureScreenImplLocked(
3793        const sp<const DisplayDevice>& hw,
3794        const sp<IGraphicBufferProducer>& producer,
3795        Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
3796        int32_t minLayerZ, int32_t maxLayerZ,
3797        bool useIdentityTransform, Transform::orientation_flags rotation,
3798        bool isLocalScreenshot)
3799{
3800    ATRACE_CALL();
3801
3802    // get screen geometry
3803    uint32_t hw_w = hw->getWidth();
3804    uint32_t hw_h = hw->getHeight();
3805
3806    if (rotation & Transform::ROT_90) {
3807        std::swap(hw_w, hw_h);
3808    }
3809
3810    if ((reqWidth > hw_w) || (reqHeight > hw_h)) {
3811        ALOGE("size mismatch (%d, %d) > (%d, %d)",
3812                reqWidth, reqHeight, hw_w, hw_h);
3813        return BAD_VALUE;
3814    }
3815
3816    reqWidth  = (!reqWidth)  ? hw_w : reqWidth;
3817    reqHeight = (!reqHeight) ? hw_h : reqHeight;
3818
3819    bool secureLayerIsVisible = false;
3820    for (const auto& layer : mDrawingState.layersSortedByZ) {
3821        const Layer::State& state(layer->getDrawingState());
3822        if ((layer->getLayerStack() != hw->getLayerStack()) ||
3823                (state.z < minLayerZ || state.z > maxLayerZ)) {
3824            continue;
3825        }
3826        layer->traverseInZOrder([&](Layer *layer) {
3827            secureLayerIsVisible = secureLayerIsVisible || (layer->isVisible() &&
3828                    layer->isSecure());
3829        });
3830    }
3831
3832    if (!isLocalScreenshot && secureLayerIsVisible) {
3833        ALOGW("FB is protected: PERMISSION_DENIED");
3834        return PERMISSION_DENIED;
3835    }
3836
3837    // create a surface (because we're a producer, and we need to
3838    // dequeue/queue a buffer)
3839    sp<Surface> sur = new Surface(producer, false);
3840    ANativeWindow* window = sur.get();
3841
3842    status_t result = native_window_api_connect(window, NATIVE_WINDOW_API_EGL);
3843    if (result == NO_ERROR) {
3844        uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
3845                        GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
3846
3847        int err = 0;
3848        err = native_window_set_buffers_dimensions(window, reqWidth, reqHeight);
3849        err |= native_window_set_scaling_mode(window, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
3850        err |= native_window_set_buffers_format(window, HAL_PIXEL_FORMAT_RGBA_8888);
3851        err |= native_window_set_usage(window, usage);
3852
3853        if (err == NO_ERROR) {
3854            ANativeWindowBuffer* buffer;
3855            /* TODO: Once we have the sync framework everywhere this can use
3856             * server-side waits on the fence that dequeueBuffer returns.
3857             */
3858            result = native_window_dequeue_buffer_and_wait(window,  &buffer);
3859            if (result == NO_ERROR) {
3860                int syncFd = -1;
3861                // create an EGLImage from the buffer so we can later
3862                // turn it into a texture
3863                EGLImageKHR image = eglCreateImageKHR(mEGLDisplay, EGL_NO_CONTEXT,
3864                        EGL_NATIVE_BUFFER_ANDROID, buffer, NULL);
3865                if (image != EGL_NO_IMAGE_KHR) {
3866                    // this binds the given EGLImage as a framebuffer for the
3867                    // duration of this scope.
3868                    RenderEngine::BindImageAsFramebuffer imageBond(getRenderEngine(), image);
3869                    if (imageBond.getStatus() == NO_ERROR) {
3870                        // this will in fact render into our dequeued buffer
3871                        // via an FBO, which means we didn't have to create
3872                        // an EGLSurface and therefore we're not
3873                        // dependent on the context's EGLConfig.
3874                        renderScreenImplLocked(
3875                            hw, sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ, true,
3876                            useIdentityTransform, rotation);
3877
3878                        // Attempt to create a sync khr object that can produce a sync point. If that
3879                        // isn't available, create a non-dupable sync object in the fallback path and
3880                        // wait on it directly.
3881                        EGLSyncKHR sync;
3882                        if (!DEBUG_SCREENSHOTS) {
3883                           sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, NULL);
3884                           // native fence fd will not be populated until flush() is done.
3885                           getRenderEngine().flush();
3886                        } else {
3887                            sync = EGL_NO_SYNC_KHR;
3888                        }
3889                        if (sync != EGL_NO_SYNC_KHR) {
3890                            // get the sync fd
3891                            syncFd = eglDupNativeFenceFDANDROID(mEGLDisplay, sync);
3892                            if (syncFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
3893                                ALOGW("captureScreen: failed to dup sync khr object");
3894                                syncFd = -1;
3895                            }
3896                            eglDestroySyncKHR(mEGLDisplay, sync);
3897                        } else {
3898                            // fallback path
3899                            sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, NULL);
3900                            if (sync != EGL_NO_SYNC_KHR) {
3901                                EGLint result = eglClientWaitSyncKHR(mEGLDisplay, sync,
3902                                    EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, 2000000000 /*2 sec*/);
3903                                EGLint eglErr = eglGetError();
3904                                if (result == EGL_TIMEOUT_EXPIRED_KHR) {
3905                                    ALOGW("captureScreen: fence wait timed out");
3906                                } else {
3907                                    ALOGW_IF(eglErr != EGL_SUCCESS,
3908                                            "captureScreen: error waiting on EGL fence: %#x", eglErr);
3909                                }
3910                                eglDestroySyncKHR(mEGLDisplay, sync);
3911                            } else {
3912                                ALOGW("captureScreen: error creating EGL fence: %#x", eglGetError());
3913                            }
3914                        }
3915                        if (DEBUG_SCREENSHOTS) {
3916                            uint32_t* pixels = new uint32_t[reqWidth*reqHeight];
3917                            getRenderEngine().readPixels(0, 0, reqWidth, reqHeight, pixels);
3918                            checkScreenshot(reqWidth, reqHeight, reqWidth, pixels,
3919                                    hw, minLayerZ, maxLayerZ);
3920                            delete [] pixels;
3921                        }
3922
3923                    } else {
3924                        ALOGE("got GL_FRAMEBUFFER_COMPLETE_OES error while taking screenshot");
3925                        result = INVALID_OPERATION;
3926                        window->cancelBuffer(window, buffer, syncFd);
3927                        buffer = NULL;
3928                    }
3929                    // destroy our image
3930                    eglDestroyImageKHR(mEGLDisplay, image);
3931                } else {
3932                    result = BAD_VALUE;
3933                }
3934                if (buffer) {
3935                    // queueBuffer takes ownership of syncFd
3936                    result = window->queueBuffer(window, buffer, syncFd);
3937                }
3938            }
3939        } else {
3940            result = BAD_VALUE;
3941        }
3942        native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
3943    }
3944
3945    return result;
3946}
3947
3948void SurfaceFlinger::checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
3949        const sp<const DisplayDevice>& hw, int32_t minLayerZ, int32_t maxLayerZ) {
3950    if (DEBUG_SCREENSHOTS) {
3951        for (size_t y=0 ; y<h ; y++) {
3952            uint32_t const * p = (uint32_t const *)vaddr + y*s;
3953            for (size_t x=0 ; x<w ; x++) {
3954                if (p[x] != 0xFF000000) return;
3955            }
3956        }
3957        ALOGE("*** we just took a black screenshot ***\n"
3958                "requested minz=%d, maxz=%d, layerStack=%d",
3959                minLayerZ, maxLayerZ, hw->getLayerStack());
3960        size_t i = 0;
3961        for (const auto& layer : mDrawingState.layersSortedByZ) {
3962            const Layer::State& state(layer->getDrawingState());
3963            if (layer->getLayerStack() == hw->getLayerStack() && state.z >= minLayerZ &&
3964                    state.z <= maxLayerZ) {
3965                layer->traverseInZOrder([&](Layer* layer) {
3966                    ALOGE("%c index=%zu, name=%s, layerStack=%d, z=%d, visible=%d, flags=%x, alpha=%x",
3967                            layer->isVisible() ? '+' : '-',
3968                            i, layer->getName().string(), layer->getLayerStack(), state.z,
3969                            layer->isVisible(), state.flags, state.alpha);
3970                    i++;
3971                });
3972            }
3973        }
3974    }
3975}
3976
3977// ---------------------------------------------------------------------------
3978
3979void SurfaceFlinger::State::traverseInZOrder(const std::function<void(Layer*)>& consume) const {
3980    layersSortedByZ.traverseInZOrder(consume);
3981}
3982
3983void SurfaceFlinger::State::traverseInReverseZOrder(const std::function<void(Layer*)>& consume) const {
3984    layersSortedByZ.traverseInReverseZOrder(consume);
3985}
3986
3987}; // namespace android
3988
3989
3990#if defined(__gl_h_)
3991#error "don't include gl/gl.h in this file"
3992#endif
3993
3994#if defined(__gl2_h_)
3995#error "don't include gl2/gl2.h in this file"
3996#endif
3997