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