services/surfaceflinger/SurfaceFlinger.cpp

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