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                 ALOGD("Backpressure trigger, skipping transaction & refresh!");
1380                 signalLayerUpdate();
1381                 break;
1382             }
1383
1384             // Now that we're going to make it to the handleMessageTransaction()
1385             // call below it's safe to call updateVrFlinger(), which will
1386             // potentially trigger a display handoff.
1387             updateVrFlinger();
1388
1389             bool refreshNeeded = handleMessageTransaction();
1390             refreshNeeded |= handleMessageInvalidate();
1391             refreshNeeded |= mRepaintEverything;
1392             if (refreshNeeded) {
1393                 // Signal a refresh if a transaction modified the window state,
1394                 // a new buffer was latched, or if HWC has requested a full
1395                 // repaint
1396                 signalRefresh();
1397             }
1398             break;
1399         }
1400         case MessageQueue::REFRESH: {
1401             handleMessageRefresh();
1402             break;
1403         }
1404     }
1405 }
1406
1407 bool SurfaceFlinger::handleMessageTransaction() {
1408     uint32_t transactionFlags = peekTransactionFlags();
1409     if (transactionFlags) {
1410         handleTransaction(transactionFlags);
1411         return true;
1412     }
1413     return false;
1414 }
1415
1416 bool SurfaceFlinger::handleMessageInvalidate() {
1417     ATRACE_CALL();
1418     return handlePageFlip();
1419 }
1420
1421 void SurfaceFlinger::handleMessageRefresh() {
1422     ATRACE_CALL();
1423
1424     mRefreshPending = false;
1425
1426     nsecs_t refreshStartTime = systemTime(SYSTEM_TIME_MONOTONIC);
1427
1428     preComposition(refreshStartTime);
1429     rebuildLayerStacks();
1430     setUpHWComposer();
1431     doDebugFlashRegions();
1432     doComposition();
1433     postComposition(refreshStartTime);
1434
1435     mPreviousPresentFence = mHwc->getPresentFence(HWC_DISPLAY_PRIMARY);
1436
1437     mHadClientComposition = false;
1438     for (size_t displayId = 0; displayId < mDisplays.size(); ++displayId) {
1439         const sp<DisplayDevice>& displayDevice = mDisplays[displayId];
1440         mHadClientComposition = mHadClientComposition ||
1441                 mHwc->hasClientComposition(displayDevice->getHwcDisplayId());
1442     }
1443
1444     mLayersWithQueuedFrames.clear();
1445 }
1446
1447 void SurfaceFlinger::doDebugFlashRegions()
1448 {
1449     // is debugging enabled
1450     if (CC_LIKELY(!mDebugRegion))
1451         return;
1452
1453     const bool repaintEverything = mRepaintEverything;
1454     for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1455         const sp<DisplayDevice>& hw(mDisplays[dpy]);
1456         if (hw->isDisplayOn()) {
1457             // transform the dirty region into this screen's coordinate space
1458             const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));
1459             if (!dirtyRegion.isEmpty()) {
1460                 // redraw the whole screen
1461                 doComposeSurfaces(hw, Region(hw->bounds()));
1462
1463                 // and draw the dirty region
1464                 const int32_t height = hw->getHeight();
1465                 RenderEngine& engine(getRenderEngine());
1466                 engine.fillRegionWithColor(dirtyRegion, height, 1, 0, 1, 1);
1467
1468                 hw->swapBuffers(getHwComposer());
1469             }
1470         }
1471     }
1472
1473     postFramebuffer();
1474
1475     if (mDebugRegion > 1) {
1476         usleep(mDebugRegion * 1000);
1477     }
1478
1479     for (size_t displayId = 0; displayId < mDisplays.size(); ++displayId) {
1480         auto& displayDevice = mDisplays[displayId];
1481         if (!displayDevice->isDisplayOn()) {
1482             continue;
1483         }
1484
1485         status_t result = displayDevice->prepareFrame(*mHwc);
1486         ALOGE_IF(result != NO_ERROR, "prepareFrame for display %zd failed:"
1487                 " %d (%s)", displayId, result, strerror(-result));
1488     }
1489 }
1490
1491 void SurfaceFlinger::preComposition(nsecs_t refreshStartTime)
1492 {
1493     ATRACE_CALL();
1494     ALOGV("preComposition");
1495
1496     bool needExtraInvalidate = false;
1497     mDrawingState.traverseInZOrder([&](Layer* layer) {
1498         if (layer->onPreComposition(refreshStartTime)) {
1499             needExtraInvalidate = true;
1500         }
1501     });
1502
1503     if (needExtraInvalidate) {
1504         signalLayerUpdate();
1505     }
1506 }
1507
1508 void SurfaceFlinger::updateCompositorTiming(
1509         nsecs_t vsyncPhase, nsecs_t vsyncInterval, nsecs_t compositeTime,
1510         std::shared_ptr<FenceTime>& presentFenceTime) {
1511     // Update queue of past composite+present times and determine the
1512     // most recently known composite to present latency.
1513     mCompositePresentTimes.push({compositeTime, presentFenceTime});
1514     nsecs_t compositeToPresentLatency = -1;
1515     while (!mCompositePresentTimes.empty()) {
1516         CompositePresentTime& cpt = mCompositePresentTimes.front();
1517         // Cached values should have been updated before calling this method,
1518         // which helps avoid duplicate syscalls.
1519         nsecs_t displayTime = cpt.display->getCachedSignalTime();
1520         if (displayTime == Fence::SIGNAL_TIME_PENDING) {
1521             break;
1522         }
1523         compositeToPresentLatency = displayTime - cpt.composite;
1524         mCompositePresentTimes.pop();
1525     }
1526
1527     // Don't let mCompositePresentTimes grow unbounded, just in case.
1528     while (mCompositePresentTimes.size() > 16) {
1529         mCompositePresentTimes.pop();
1530     }
1531
1532     setCompositorTimingSnapped(
1533             vsyncPhase, vsyncInterval, compositeToPresentLatency);
1534 }
1535
1536 void SurfaceFlinger::setCompositorTimingSnapped(nsecs_t vsyncPhase,
1537         nsecs_t vsyncInterval, nsecs_t compositeToPresentLatency) {
1538     // Integer division and modulo round toward 0 not -inf, so we need to
1539     // treat negative and positive offsets differently.
1540     nsecs_t idealLatency = (sfVsyncPhaseOffsetNs > 0) ?
1541             (vsyncInterval - (sfVsyncPhaseOffsetNs % vsyncInterval)) :
1542             ((-sfVsyncPhaseOffsetNs) % vsyncInterval);
1543
1544     // Just in case sfVsyncPhaseOffsetNs == -vsyncInterval.
1545     if (idealLatency <= 0) {
1546         idealLatency = vsyncInterval;
1547     }
1548
1549     // Snap the latency to a value that removes scheduling jitter from the
1550     // composition and present times, which often have >1ms of jitter.
1551     // Reducing jitter is important if an app attempts to extrapolate
1552     // something (such as user input) to an accurate diasplay time.
1553     // Snapping also allows an app to precisely calculate sfVsyncPhaseOffsetNs
1554     // with (presentLatency % interval).
1555     nsecs_t bias = vsyncInterval / 2;
1556     int64_t extraVsyncs =
1557             (compositeToPresentLatency - idealLatency + bias) / vsyncInterval;
1558     nsecs_t snappedCompositeToPresentLatency = (extraVsyncs > 0) ?
1559             idealLatency + (extraVsyncs * vsyncInterval) : idealLatency;
1560
1561     std::lock_guard<std::mutex> lock(mCompositorTimingLock);
1562     mCompositorTiming.deadline = vsyncPhase - idealLatency;
1563     mCompositorTiming.interval = vsyncInterval;
1564     mCompositorTiming.presentLatency = snappedCompositeToPresentLatency;
1565 }
1566
1567 void SurfaceFlinger::postComposition(nsecs_t refreshStartTime)
1568 {
1569     ATRACE_CALL();
1570     ALOGV("postComposition");
1571
1572     // Release any buffers which were replaced this frame
1573     nsecs_t dequeueReadyTime = systemTime();
1574     for (auto& layer : mLayersWithQueuedFrames) {
1575         layer->releasePendingBuffer(dequeueReadyTime);
1576     }
1577
1578     // |mStateLock| not needed as we are on the main thread
1579     const sp<const DisplayDevice> hw(getDefaultDisplayDeviceLocked());
1580
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     mGlCompositionDoneTimeline.updateSignalTimes();
1590
1591     sp<Fence> presentFence = mHwc->getPresentFence(HWC_DISPLAY_PRIMARY);
1592     auto presentFenceTime = std::make_shared<FenceTime>(presentFence);
1593     mDisplayTimeline.push(presentFenceTime);
1594     mDisplayTimeline.updateSignalTimes();
1595
1596     nsecs_t vsyncPhase = mPrimaryDispSync.computeNextRefresh(0);
1597     nsecs_t vsyncInterval = mPrimaryDispSync.getPeriod();
1598
1599     // We use the refreshStartTime which might be sampled a little later than
1600     // when we started doing work for this frame, but that should be okay
1601     // since updateCompositorTiming has snapping logic.
1602     updateCompositorTiming(
1603         vsyncPhase, vsyncInterval, refreshStartTime, presentFenceTime);
1604     CompositorTiming compositorTiming;
1605     {
1606         std::lock_guard<std::mutex> lock(mCompositorTimingLock);
1607         compositorTiming = mCompositorTiming;
1608     }
1609
1610     mDrawingState.traverseInZOrder([&](Layer* layer) {
1611         bool frameLatched = layer->onPostComposition(glCompositionDoneFenceTime,
1612                 presentFenceTime, compositorTiming);
1613         if (frameLatched) {
1614             recordBufferingStats(layer->getName().string(),
1615                     layer->getOccupancyHistory(false));
1616         }
1617     });
1618
1619     if (presentFence->isValid()) {
1620         if (mPrimaryDispSync.addPresentFence(presentFence)) {
1621             enableHardwareVsync();
1622         } else {
1623             disableHardwareVsync(false);
1624         }
1625     }
1626
1627     if (!hasSyncFramework) {
1628         if (hw->isDisplayOn()) {
1629             enableHardwareVsync();
1630         }
1631     }
1632
1633     if (mAnimCompositionPending) {
1634         mAnimCompositionPending = false;
1635
1636         if (presentFenceTime->isValid()) {
1637             mAnimFrameTracker.setActualPresentFence(
1638                     std::move(presentFenceTime));
1639         } else {
1640             // The HWC doesn't support present fences, so use the refresh
1641             // timestamp instead.
1642             nsecs_t presentTime =
1643                     mHwc->getRefreshTimestamp(HWC_DISPLAY_PRIMARY);
1644             mAnimFrameTracker.setActualPresentTime(presentTime);
1645         }
1646         mAnimFrameTracker.advanceFrame();
1647     }
1648
1649     if (hw->getPowerMode() == HWC_POWER_MODE_OFF) {
1650         return;
1651     }
1652
1653     nsecs_t currentTime = systemTime();
1654     if (mHasPoweredOff) {
1655         mHasPoweredOff = false;
1656     } else {
1657         nsecs_t elapsedTime = currentTime - mLastSwapTime;
1658         size_t numPeriods = static_cast<size_t>(elapsedTime / vsyncInterval);
1659         if (numPeriods < NUM_BUCKETS - 1) {
1660             mFrameBuckets[numPeriods] += elapsedTime;
1661         } else {
1662             mFrameBuckets[NUM_BUCKETS - 1] += elapsedTime;
1663         }
1664         mTotalTime += elapsedTime;
1665     }
1666     mLastSwapTime = currentTime;
1667 }
1668
1669 void SurfaceFlinger::rebuildLayerStacks() {
1670     ATRACE_CALL();
1671     ALOGV("rebuildLayerStacks");
1672
1673     // rebuild the visible layer list per screen
1674     if (CC_UNLIKELY(mVisibleRegionsDirty)) {
1675         ATRACE_CALL();
1676         mVisibleRegionsDirty = false;
1677         invalidateHwcGeometry();
1678
1679         for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1680             Region opaqueRegion;
1681             Region dirtyRegion;
1682             Vector<sp<Layer>> layersSortedByZ;
1683             const sp<DisplayDevice>& displayDevice(mDisplays[dpy]);
1684             const Transform& tr(displayDevice->getTransform());
1685             const Rect bounds(displayDevice->getBounds());
1686             if (displayDevice->isDisplayOn()) {
1687                 computeVisibleRegions(displayDevice, dirtyRegion, opaqueRegion);
1688
1689                 mDrawingState.traverseInZOrder([&](Layer* layer) {
1690                     if (layer->belongsToDisplay(displayDevice->getLayerStack(),
1691                                 displayDevice->isPrimary())) {
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 (layer->belongsToDisplay(hw->getLayerStack(), hw->isPrimary())) {
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, 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(const sp<const DisplayDevice>& displayDevice,
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->belongsToDisplay(displayDevice->getLayerStack(), displayDevice->isPrimary()))
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(const sp<const Layer>& layer, const Region& dirty) {
2444     for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
2445         const sp<DisplayDevice>& hw(mDisplays[dpy]);
2446         if (layer->belongsToDisplay(hw->getLayerStack(), hw->isPrimary())) {
2447             hw->dirtyRegion.orSelf(dirty);
2448         }
2449     }
2450 }
2451
2452 bool SurfaceFlinger::handlePageFlip()
2453 {
2454     ALOGV("handlePageFlip");
2455
2456     nsecs_t latchTime = systemTime();
2457
2458     bool visibleRegions = false;
2459     bool frameQueued = false;
2460     bool newDataLatched = false;
2461
2462     // Store the set of layers that need updates. This set must not change as
2463     // buffers are being latched, as this could result in a deadlock.
2464     // Example: Two producers share the same command stream and:
2465     // 1.) Layer 0 is latched
2466     // 2.) Layer 0 gets a new frame
2467     // 2.) Layer 1 gets a new frame
2468     // 3.) Layer 1 is latched.
2469     // Display is now waiting on Layer 1's frame, which is behind layer 0's
2470     // second frame. But layer 0's second frame could be waiting on display.
2471     mDrawingState.traverseInZOrder([&](Layer* layer) {
2472         if (layer->hasQueuedFrame()) {
2473             frameQueued = true;
2474             if (layer->shouldPresentNow(mPrimaryDispSync)) {
2475                 mLayersWithQueuedFrames.push_back(layer);
2476             } else {
2477                 layer->useEmptyDamage();
2478             }
2479         } else {
2480             layer->useEmptyDamage();
2481         }
2482     });
2483
2484     for (auto& layer : mLayersWithQueuedFrames) {
2485         const Region dirty(layer->latchBuffer(visibleRegions, latchTime));
2486         layer->useSurfaceDamage();
2487         invalidateLayerStack(layer, dirty);
2488         if (layer->isBufferLatched()) {
2489             newDataLatched = true;
2490         }
2491     }
2492
2493     mVisibleRegionsDirty |= visibleRegions;
2494
2495     // If we will need to wake up at some time in the future to deal with a
2496     // queued frame that shouldn't be displayed during this vsync period, wake
2497     // up during the next vsync period to check again.
2498     if (frameQueued && (mLayersWithQueuedFrames.empty() || !newDataLatched)) {
2499         signalLayerUpdate();
2500     }
2501
2502     // Only continue with the refresh if there is actually new work to do
2503     return !mLayersWithQueuedFrames.empty() && newDataLatched;
2504 }
2505
2506 void SurfaceFlinger::invalidateHwcGeometry()
2507 {
2508     mGeometryInvalid = true;
2509 }
2510
2511
2512 void SurfaceFlinger::doDisplayComposition(
2513         const sp<const DisplayDevice>& displayDevice,
2514         const Region& inDirtyRegion)
2515 {
2516     // We only need to actually compose the display if:
2517     // 1) It is being handled by hardware composer, which may need this to
2518     //    keep its virtual display state machine in sync, or
2519     // 2) There is work to be done (the dirty region isn't empty)
2520     bool isHwcDisplay = displayDevice->getHwcDisplayId() >= 0;
2521     if (!isHwcDisplay && inDirtyRegion.isEmpty()) {
2522         ALOGV("Skipping display composition");
2523         return;
2524     }
2525
2526     ALOGV("doDisplayComposition");
2527
2528     Region dirtyRegion(inDirtyRegion);
2529
2530     // compute the invalid region
2531     displayDevice->swapRegion.orSelf(dirtyRegion);
2532
2533     uint32_t flags = displayDevice->getFlags();
2534     if (flags & DisplayDevice::SWAP_RECTANGLE) {
2535         // we can redraw only what's dirty, but since SWAP_RECTANGLE only
2536         // takes a rectangle, we must make sure to update that whole
2537         // rectangle in that case
2538         dirtyRegion.set(displayDevice->swapRegion.bounds());
2539     } else {
2540         if (flags & DisplayDevice::PARTIAL_UPDATES) {
2541             // We need to redraw the rectangle that will be updated
2542             // (pushed to the framebuffer).
2543             // This is needed because PARTIAL_UPDATES only takes one
2544             // rectangle instead of a region (see DisplayDevice::flip())
2545             dirtyRegion.set(displayDevice->swapRegion.bounds());
2546         } else {
2547             // we need to redraw everything (the whole screen)
2548             dirtyRegion.set(displayDevice->bounds());
2549             displayDevice->swapRegion = dirtyRegion;
2550         }
2551     }
2552
2553     if (!doComposeSurfaces(displayDevice, dirtyRegion)) return;
2554
2555     // update the swap region and clear the dirty region
2556     displayDevice->swapRegion.orSelf(dirtyRegion);
2557
2558     // swap buffers (presentation)
2559     displayDevice->swapBuffers(getHwComposer());
2560 }
2561
2562 bool SurfaceFlinger::doComposeSurfaces(
2563         const sp<const DisplayDevice>& displayDevice, const Region& dirty)
2564 {
2565     ALOGV("doComposeSurfaces");
2566
2567     const auto hwcId = displayDevice->getHwcDisplayId();
2568
2569     mat4 oldColorMatrix;
2570     const bool applyColorMatrix = !mHwc->hasDeviceComposition(hwcId) &&
2571             !mHwc->hasCapability(HWC2::Capability::SkipClientColorTransform);
2572     if (applyColorMatrix) {
2573         mat4 colorMatrix = mColorMatrix * mDaltonizer();
2574         oldColorMatrix = getRenderEngine().setupColorTransform(colorMatrix);
2575     }
2576
2577     bool hasClientComposition = mHwc->hasClientComposition(hwcId);
2578     if (hasClientComposition) {
2579         ALOGV("hasClientComposition");
2580
2581 #ifdef USE_HWC2
2582         mRenderEngine->setWideColor(displayDevice->getWideColorSupport());
2583         mRenderEngine->setColorMode(displayDevice->getActiveColorMode());
2584 #endif
2585         if (!displayDevice->makeCurrent(mEGLDisplay, mEGLContext)) {
2586             ALOGW("DisplayDevice::makeCurrent failed. Aborting surface composition for display %s",
2587                   displayDevice->getDisplayName().string());
2588             eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
2589
2590             // |mStateLock| not needed as we are on the main thread
2591             if(!getDefaultDisplayDeviceLocked()->makeCurrent(mEGLDisplay, mEGLContext)) {
2592               ALOGE("DisplayDevice::makeCurrent on default display failed. Aborting.");
2593             }
2594             return false;
2595         }
2596
2597         // Never touch the framebuffer if we don't have any framebuffer layers
2598         const bool hasDeviceComposition = mHwc->hasDeviceComposition(hwcId);
2599         if (hasDeviceComposition) {
2600             // when using overlays, we assume a fully transparent framebuffer
2601             // NOTE: we could reduce how much we need to clear, for instance
2602             // remove where there are opaque FB layers. however, on some
2603             // GPUs doing a "clean slate" clear might be more efficient.
2604             // We'll revisit later if needed.
2605             mRenderEngine->clearWithColor(0, 0, 0, 0);
2606         } else {
2607             // we start with the whole screen area
2608             const Region bounds(displayDevice->getBounds());
2609
2610             // we remove the scissor part
2611             // we're left with the letterbox region
2612             // (common case is that letterbox ends-up being empty)
2613             const Region letterbox(bounds.subtract(displayDevice->getScissor()));
2614
2615             // compute the area to clear
2616             Region region(displayDevice->undefinedRegion.merge(letterbox));
2617
2618             // but limit it to the dirty region
2619             region.andSelf(dirty);
2620
2621             // screen is already cleared here
2622             if (!region.isEmpty()) {
2623                 // can happen with SurfaceView
2624                 drawWormhole(displayDevice, region);
2625             }
2626         }
2627
2628         if (displayDevice->getDisplayType() != DisplayDevice::DISPLAY_PRIMARY) {
2629             // just to be on the safe side, we don't set the
2630             // scissor on the main display. It should never be needed
2631             // anyways (though in theory it could since the API allows it).
2632             const Rect& bounds(displayDevice->getBounds());
2633             const Rect& scissor(displayDevice->getScissor());
2634             if (scissor != bounds) {
2635                 // scissor doesn't match the screen's dimensions, so we
2636                 // need to clear everything outside of it and enable
2637                 // the GL scissor so we don't draw anything where we shouldn't
2638
2639                 // enable scissor for this frame
2640                 const uint32_t height = displayDevice->getHeight();
2641                 mRenderEngine->setScissor(scissor.left, height - scissor.bottom,
2642                         scissor.getWidth(), scissor.getHeight());
2643             }
2644         }
2645     }
2646
2647     /*
2648      * and then, render the layers targeted at the framebuffer
2649      */
2650
2651     ALOGV("Rendering client layers");
2652     const Transform& displayTransform = displayDevice->getTransform();
2653     if (hwcId >= 0) {
2654         // we're using h/w composer
2655         bool firstLayer = true;
2656         for (auto& layer : displayDevice->getVisibleLayersSortedByZ()) {
2657             const Region clip(dirty.intersect(
2658                     displayTransform.transform(layer->visibleRegion)));
2659             ALOGV("Layer: %s", layer->getName().string());
2660             ALOGV("  Composition type: %s",
2661                     to_string(layer->getCompositionType(hwcId)).c_str());
2662             if (!clip.isEmpty()) {
2663                 switch (layer->getCompositionType(hwcId)) {
2664                     case HWC2::Composition::Cursor:
2665                     case HWC2::Composition::Device:
2666                     case HWC2::Composition::Sideband:
2667                     case HWC2::Composition::SolidColor: {
2668                         const Layer::State& state(layer->getDrawingState());
2669                         if (layer->getClearClientTarget(hwcId) && !firstLayer &&
2670                                 layer->isOpaque(state) && (state.alpha == 1.0f)
2671                                 && hasClientComposition) {
2672                             // never clear the very first layer since we're
2673                             // guaranteed the FB is already cleared
2674                             layer->clearWithOpenGL(displayDevice);
2675                         }
2676                         break;
2677                     }
2678                     case HWC2::Composition::Client: {
2679                         layer->draw(displayDevice, clip);
2680                         break;
2681                     }
2682                     default:
2683                         break;
2684                 }
2685             } else {
2686                 ALOGV("  Skipping for empty clip");
2687             }
2688             firstLayer = false;
2689         }
2690     } else {
2691         // we're not using h/w composer
2692         for (auto& layer : displayDevice->getVisibleLayersSortedByZ()) {
2693             const Region clip(dirty.intersect(
2694                     displayTransform.transform(layer->visibleRegion)));
2695             if (!clip.isEmpty()) {
2696                 layer->draw(displayDevice, clip);
2697             }
2698         }
2699     }
2700
2701     if (applyColorMatrix) {
2702         getRenderEngine().setupColorTransform(oldColorMatrix);
2703     }
2704
2705     // disable scissor at the end of the frame
2706     mRenderEngine->disableScissor();
2707     return true;
2708 }
2709
2710 void SurfaceFlinger::drawWormhole(const sp<const DisplayDevice>& displayDevice, const Region& region) const {
2711     const int32_t height = displayDevice->getHeight();
2712     RenderEngine& engine(getRenderEngine());
2713     engine.fillRegionWithColor(region, height, 0, 0, 0, 0);
2714 }
2715
2716 status_t SurfaceFlinger::addClientLayer(const sp<Client>& client,
2717         const sp<IBinder>& handle,
2718         const sp<IGraphicBufferProducer>& gbc,
2719         const sp<Layer>& lbc,
2720         const sp<Layer>& parent)
2721 {
2722     // add this layer to the current state list
2723     {
2724         Mutex::Autolock _l(mStateLock);
2725         if (mNumLayers >= MAX_LAYERS) {
2726             ALOGE("AddClientLayer failed, mNumLayers (%zu) >= MAX_LAYERS (%zu)", mNumLayers,
2727                   MAX_LAYERS);
2728             return NO_MEMORY;
2729         }
2730         if (parent == nullptr) {
2731             mCurrentState.layersSortedByZ.add(lbc);
2732         } else {
2733             if (mCurrentState.layersSortedByZ.indexOf(parent) < 0) {
2734                 ALOGE("addClientLayer called with a removed parent");
2735                 return NAME_NOT_FOUND;
2736             }
2737             parent->addChild(lbc);
2738         }
2739
2740         mGraphicBufferProducerList.add(IInterface::asBinder(gbc));
2741         mLayersAdded = true;
2742         mNumLayers++;
2743     }
2744
2745     // attach this layer to the client
2746     client->attachLayer(handle, lbc);
2747
2748     return NO_ERROR;
2749 }
2750
2751 status_t SurfaceFlinger::removeLayer(const sp<Layer>& layer, bool topLevelOnly) {
2752     Mutex::Autolock _l(mStateLock);
2753
2754     const auto& p = layer->getParent();
2755     ssize_t index;
2756     if (p != nullptr) {
2757         if (topLevelOnly) {
2758             return NO_ERROR;
2759         }
2760
2761         sp<Layer> ancestor = p;
2762         while (ancestor->getParent() != nullptr) {
2763             ancestor = ancestor->getParent();
2764         }
2765         if (mCurrentState.layersSortedByZ.indexOf(ancestor) < 0) {
2766             ALOGE("removeLayer called with a layer whose parent has been removed");
2767             return NAME_NOT_FOUND;
2768         }
2769
2770         index = p->removeChild(layer);
2771     } else {
2772         index = mCurrentState.layersSortedByZ.remove(layer);
2773     }
2774
2775     // As a matter of normal operation, the LayerCleaner will produce a second
2776     // attempt to remove the surface. The Layer will be kept alive in mDrawingState
2777     // so we will succeed in promoting it, but it's already been removed
2778     // from mCurrentState. As long as we can find it in mDrawingState we have no problem
2779     // otherwise something has gone wrong and we are leaking the layer.
2780     if (index < 0 && mDrawingState.layersSortedByZ.indexOf(layer) < 0) {
2781         ALOGE("Failed to find layer (%s) in layer parent (%s).",
2782                 layer->getName().string(),
2783                 (p != nullptr) ? p->getName().string() : "no-parent");
2784         return BAD_VALUE;
2785     } else if (index < 0) {
2786         return NO_ERROR;
2787     }
2788
2789     mLayersPendingRemoval.add(layer);
2790     mLayersRemoved = true;
2791     mNumLayers -= 1 + layer->getChildrenCount();
2792     setTransactionFlags(eTransactionNeeded);
2793     return NO_ERROR;
2794 }
2795
2796 uint32_t SurfaceFlinger::peekTransactionFlags() {
2797     return android_atomic_release_load(&mTransactionFlags);
2798 }
2799
2800 uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags) {
2801     return android_atomic_and(~flags, &mTransactionFlags) & flags;
2802 }
2803
2804 uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags) {
2805     uint32_t old = android_atomic_or(flags, &mTransactionFlags);
2806     if ((old & flags)==0) { // wake the server up
2807         signalTransaction();
2808     }
2809     return old;
2810 }
2811
2812 void SurfaceFlinger::setTransactionState(
2813         const Vector<ComposerState>& state,
2814         const Vector<DisplayState>& displays,
2815         uint32_t flags)
2816 {
2817     ATRACE_CALL();
2818     Mutex::Autolock _l(mStateLock);
2819     uint32_t transactionFlags = 0;
2820
2821     if (flags & eAnimation) {
2822         // For window updates that are part of an animation we must wait for
2823         // previous animation "frames" to be handled.
2824         while (mAnimTransactionPending) {
2825             status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
2826             if (CC_UNLIKELY(err != NO_ERROR)) {
2827                 // just in case something goes wrong in SF, return to the
2828                 // caller after a few seconds.
2829                 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out "
2830                         "waiting for previous animation frame");
2831                 mAnimTransactionPending = false;
2832                 break;
2833             }
2834         }
2835     }
2836
2837     size_t count = displays.size();
2838     for (size_t i=0 ; i<count ; i++) {
2839         const DisplayState& s(displays[i]);
2840         transactionFlags |= setDisplayStateLocked(s);
2841     }
2842
2843     count = state.size();
2844     for (size_t i=0 ; i<count ; i++) {
2845         const ComposerState& s(state[i]);
2846         // Here we need to check that the interface we're given is indeed
2847         // one of our own. A malicious client could give us a NULL
2848         // IInterface, or one of its own or even one of our own but a
2849         // different type. All these situations would cause us to crash.
2850         //
2851         // NOTE: it would be better to use RTTI as we could directly check
2852         // that we have a Client*. however, RTTI is disabled in Android.
2853         if (s.client != NULL) {
2854             sp<IBinder> binder = IInterface::asBinder(s.client);
2855             if (binder != NULL) {
2856                 if (binder->queryLocalInterface(ISurfaceComposerClient::descriptor) != NULL) {
2857                     sp<Client> client( static_cast<Client *>(s.client.get()) );
2858                     transactionFlags |= setClientStateLocked(client, s.state);
2859                 }
2860             }
2861         }
2862     }
2863
2864     // If a synchronous transaction is explicitly requested without any changes,
2865     // force a transaction anyway. This can be used as a flush mechanism for
2866     // previous async transactions.
2867     if (transactionFlags == 0 && (flags & eSynchronous)) {
2868         transactionFlags = eTransactionNeeded;
2869     }
2870
2871     if (transactionFlags) {
2872         if (mInterceptor.isEnabled()) {
2873             mInterceptor.saveTransaction(state, mCurrentState.displays, displays, flags);
2874         }
2875
2876         // this triggers the transaction
2877         setTransactionFlags(transactionFlags);
2878
2879         // if this is a synchronous transaction, wait for it to take effect
2880         // before returning.
2881         if (flags & eSynchronous) {
2882             mTransactionPending = true;
2883         }
2884         if (flags & eAnimation) {
2885             mAnimTransactionPending = true;
2886         }
2887         while (mTransactionPending) {
2888             status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
2889             if (CC_UNLIKELY(err != NO_ERROR)) {
2890                 // just in case something goes wrong in SF, return to the
2891                 // called after a few seconds.
2892                 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!");
2893                 mTransactionPending = false;
2894                 break;
2895             }
2896         }
2897     }
2898 }
2899
2900 uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s)
2901 {
2902     ssize_t dpyIdx = mCurrentState.displays.indexOfKey(s.token);
2903     if (dpyIdx < 0)
2904         return 0;
2905
2906     uint32_t flags = 0;
2907     DisplayDeviceState& disp(mCurrentState.displays.editValueAt(dpyIdx));
2908     if (disp.isValid()) {
2909         const uint32_t what = s.what;
2910         if (what & DisplayState::eSurfaceChanged) {
2911             if (IInterface::asBinder(disp.surface) != IInterface::asBinder(s.surface)) {
2912                 disp.surface = s.surface;
2913                 flags |= eDisplayTransactionNeeded;
2914             }
2915         }
2916         if (what & DisplayState::eLayerStackChanged) {
2917             if (disp.layerStack != s.layerStack) {
2918                 disp.layerStack = s.layerStack;
2919                 flags |= eDisplayTransactionNeeded;
2920             }
2921         }
2922         if (what & DisplayState::eDisplayProjectionChanged) {
2923             if (disp.orientation != s.orientation) {
2924                 disp.orientation = s.orientation;
2925                 flags |= eDisplayTransactionNeeded;
2926             }
2927             if (disp.frame != s.frame) {
2928                 disp.frame = s.frame;
2929                 flags |= eDisplayTransactionNeeded;
2930             }
2931             if (disp.viewport != s.viewport) {
2932                 disp.viewport = s.viewport;
2933                 flags |= eDisplayTransactionNeeded;
2934             }
2935         }
2936         if (what & DisplayState::eDisplaySizeChanged) {
2937             if (disp.width != s.width) {
2938                 disp.width = s.width;
2939                 flags |= eDisplayTransactionNeeded;
2940             }
2941             if (disp.height != s.height) {
2942                 disp.height = s.height;
2943                 flags |= eDisplayTransactionNeeded;
2944             }
2945         }
2946     }
2947     return flags;
2948 }
2949
2950 uint32_t SurfaceFlinger::setClientStateLocked(
2951         const sp<Client>& client,
2952         const layer_state_t& s)
2953 {
2954     uint32_t flags = 0;
2955     sp<Layer> layer(client->getLayerUser(s.surface));
2956     if (layer != 0) {
2957         const uint32_t what = s.what;
2958         bool geometryAppliesWithResize =
2959                 what & layer_state_t::eGeometryAppliesWithResize;
2960         if (what & layer_state_t::ePositionChanged) {
2961             if (layer->setPosition(s.x, s.y, !geometryAppliesWithResize)) {
2962                 flags |= eTraversalNeeded;
2963             }
2964         }
2965         if (what & layer_state_t::eLayerChanged) {
2966             // NOTE: index needs to be calculated before we update the state
2967             const auto& p = layer->getParent();
2968             if (p == nullptr) {
2969                 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
2970                 if (layer->setLayer(s.z) && idx >= 0) {
2971                     mCurrentState.layersSortedByZ.removeAt(idx);
2972                     mCurrentState.layersSortedByZ.add(layer);
2973                     // we need traversal (state changed)
2974                     // AND transaction (list changed)
2975                     flags |= eTransactionNeeded|eTraversalNeeded;
2976                 }
2977             } else {
2978                 if (p->setChildLayer(layer, s.z)) {
2979                     flags |= eTransactionNeeded|eTraversalNeeded;
2980                 }
2981             }
2982         }
2983         if (what & layer_state_t::eRelativeLayerChanged) {
2984             if (layer->setRelativeLayer(s.relativeLayerHandle, s.z)) {
2985                 flags |= eTransactionNeeded|eTraversalNeeded;
2986             }
2987         }
2988         if (what & layer_state_t::eSizeChanged) {
2989             if (layer->setSize(s.w, s.h)) {
2990                 flags |= eTraversalNeeded;
2991             }
2992         }
2993         if (what & layer_state_t::eAlphaChanged) {
2994             if (layer->setAlpha(s.alpha))
2995                 flags |= eTraversalNeeded;
2996         }
2997         if (what & layer_state_t::eMatrixChanged) {
2998             if (layer->setMatrix(s.matrix))
2999                 flags |= eTraversalNeeded;
3000         }
3001         if (what & layer_state_t::eTransparentRegionChanged) {
3002             if (layer->setTransparentRegionHint(s.transparentRegion))
3003                 flags |= eTraversalNeeded;
3004         }
3005         if (what & layer_state_t::eFlagsChanged) {
3006             if (layer->setFlags(s.flags, s.mask))
3007                 flags |= eTraversalNeeded;
3008         }
3009         if (what & layer_state_t::eCropChanged) {
3010             if (layer->setCrop(s.crop, !geometryAppliesWithResize))
3011                 flags |= eTraversalNeeded;
3012         }
3013         if (what & layer_state_t::eFinalCropChanged) {
3014             if (layer->setFinalCrop(s.finalCrop, !geometryAppliesWithResize))
3015                 flags |= eTraversalNeeded;
3016         }
3017         if (what & layer_state_t::eLayerStackChanged) {
3018             ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
3019             // We only allow setting layer stacks for top level layers,
3020             // everything else inherits layer stack from its parent.
3021             if (layer->hasParent()) {
3022                 ALOGE("Attempt to set layer stack on layer with parent (%s) is invalid",
3023                         layer->getName().string());
3024             } else if (idx < 0) {
3025                 ALOGE("Attempt to set layer stack on layer without parent (%s) that "
3026                         "that also does not appear in the top level layer list. Something"
3027                         " has gone wrong.", layer->getName().string());
3028             } else if (layer->setLayerStack(s.layerStack)) {
3029                 mCurrentState.layersSortedByZ.removeAt(idx);
3030                 mCurrentState.layersSortedByZ.add(layer);
3031                 // we need traversal (state changed)
3032                 // AND transaction (list changed)
3033                 flags |= eTransactionNeeded|eTraversalNeeded;
3034             }
3035         }
3036         if (what & layer_state_t::eDeferTransaction) {
3037             if (s.barrierHandle != nullptr) {
3038                 layer->deferTransactionUntil(s.barrierHandle, s.frameNumber);
3039             } else if (s.barrierGbp != nullptr) {
3040                 const sp<IGraphicBufferProducer>& gbp = s.barrierGbp;
3041                 if (authenticateSurfaceTextureLocked(gbp)) {
3042                     const auto& otherLayer =
3043                         (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
3044                     layer->deferTransactionUntil(otherLayer, s.frameNumber);
3045                 } else {
3046                     ALOGE("Attempt to defer transaction to to an"
3047                             " unrecognized GraphicBufferProducer");
3048                 }
3049             }
3050             // We don't trigger a traversal here because if no other state is
3051             // changed, we don't want this to cause any more work
3052         }
3053         if (what & layer_state_t::eReparentChildren) {
3054             if (layer->reparentChildren(s.reparentHandle)) {
3055                 flags |= eTransactionNeeded|eTraversalNeeded;
3056             }
3057         }
3058         if (what & layer_state_t::eDetachChildren) {
3059             layer->detachChildren();
3060         }
3061         if (what & layer_state_t::eOverrideScalingModeChanged) {
3062             layer->setOverrideScalingMode(s.overrideScalingMode);
3063             // We don't trigger a traversal here because if no other state is
3064             // changed, we don't want this to cause any more work
3065         }
3066     }
3067     return flags;
3068 }
3069
3070 status_t SurfaceFlinger::createLayer(
3071         const String8& name,
3072         const sp<Client>& client,
3073         uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
3074         uint32_t windowType, uint32_t ownerUid, sp<IBinder>* handle,
3075         sp<IGraphicBufferProducer>* gbp, sp<Layer>* parent)
3076 {
3077     if (int32_t(w|h) < 0) {
3078         ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
3079                 int(w), int(h));
3080         return BAD_VALUE;
3081     }
3082
3083     status_t result = NO_ERROR;
3084
3085     sp<Layer> layer;
3086
3087     String8 uniqueName = getUniqueLayerName(name);
3088
3089     switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
3090         case ISurfaceComposerClient::eFXSurfaceNormal:
3091             result = createNormalLayer(client,
3092                     uniqueName, w, h, flags, format,
3093                     handle, gbp, &layer);
3094             break;
3095         case ISurfaceComposerClient::eFXSurfaceDim:
3096             result = createDimLayer(client,
3097                     uniqueName, w, h, flags,
3098                     handle, gbp, &layer);
3099             break;
3100         default:
3101             result = BAD_VALUE;
3102             break;
3103     }
3104
3105     if (result != NO_ERROR) {
3106         return result;
3107     }
3108
3109     // window type is WINDOW_TYPE_DONT_SCREENSHOT from SurfaceControl.java
3110     // TODO b/64227542
3111     if (windowType == 441731) {
3112         windowType = 2024; // TYPE_NAVIGATION_BAR_PANEL
3113         layer->setPrimaryDisplayOnly();
3114     }
3115
3116     layer->setInfo(windowType, ownerUid);
3117
3118     result = addClientLayer(client, *handle, *gbp, layer, *parent);
3119     if (result != NO_ERROR) {
3120         return result;
3121     }
3122     mInterceptor.saveSurfaceCreation(layer);
3123
3124     setTransactionFlags(eTransactionNeeded);
3125     return result;
3126 }
3127
3128 String8 SurfaceFlinger::getUniqueLayerName(const String8& name)
3129 {
3130     bool matchFound = true;
3131     uint32_t dupeCounter = 0;
3132
3133     // Tack on our counter whether there is a hit or not, so everyone gets a tag
3134     String8 uniqueName = name + "#" + String8(std::to_string(dupeCounter).c_str());
3135
3136     // Loop over layers until we're sure there is no matching name
3137     while (matchFound) {
3138         matchFound = false;
3139         mDrawingState.traverseInZOrder([&](Layer* layer) {
3140             if (layer->getName() == uniqueName) {
3141                 matchFound = true;
3142                 uniqueName = name + "#" + String8(std::to_string(++dupeCounter).c_str());
3143             }
3144         });
3145     }
3146
3147     ALOGD_IF(dupeCounter > 0, "duplicate layer name: changing %s to %s", name.c_str(), uniqueName.c_str());
3148
3149     return uniqueName;
3150 }
3151
3152 status_t SurfaceFlinger::createNormalLayer(const sp<Client>& client,
3153         const String8& name, uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
3154         sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
3155 {
3156     // initialize the surfaces
3157     switch (format) {
3158     case PIXEL_FORMAT_TRANSPARENT:
3159     case PIXEL_FORMAT_TRANSLUCENT:
3160         format = PIXEL_FORMAT_RGBA_8888;
3161         break;
3162     case PIXEL_FORMAT_OPAQUE:
3163         format = PIXEL_FORMAT_RGBX_8888;
3164         break;
3165     }
3166
3167     *outLayer = new Layer(this, client, name, w, h, flags);
3168     status_t err = (*outLayer)->setBuffers(w, h, format, flags);
3169     if (err == NO_ERROR) {
3170         *handle = (*outLayer)->getHandle();
3171         *gbp = (*outLayer)->getProducer();
3172     }
3173
3174     ALOGE_IF(err, "createNormalLayer() failed (%s)", strerror(-err));
3175     return err;
3176 }
3177
3178 status_t SurfaceFlinger::createDimLayer(const sp<Client>& client,
3179         const String8& name, uint32_t w, uint32_t h, uint32_t flags,
3180         sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
3181 {
3182     *outLayer = new LayerDim(this, client, name, w, h, flags);
3183     *handle = (*outLayer)->getHandle();
3184     *gbp = (*outLayer)->getProducer();
3185     return NO_ERROR;
3186 }
3187
3188 status_t SurfaceFlinger::onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle)
3189 {
3190     // called by a client when it wants to remove a Layer
3191     status_t err = NO_ERROR;
3192     sp<Layer> l(client->getLayerUser(handle));
3193     if (l != NULL) {
3194         mInterceptor.saveSurfaceDeletion(l);
3195         err = removeLayer(l);
3196         ALOGE_IF(err<0 && err != NAME_NOT_FOUND,
3197                 "error removing layer=%p (%s)", l.get(), strerror(-err));
3198     }
3199     return err;
3200 }
3201
3202 status_t SurfaceFlinger::onLayerDestroyed(const wp<Layer>& layer)
3203 {
3204     // called by ~LayerCleaner() when all references to the IBinder (handle)
3205     // are gone
3206     sp<Layer> l = layer.promote();
3207     if (l == nullptr) {
3208         // The layer has already been removed, carry on
3209         return NO_ERROR;
3210     }
3211     // If we have a parent, then we can continue to live as long as it does.
3212     return removeLayer(l, true);
3213 }
3214
3215 // ---------------------------------------------------------------------------
3216
3217 void SurfaceFlinger::onInitializeDisplays() {
3218     // reset screen orientation and use primary layer stack
3219     Vector<ComposerState> state;
3220     Vector<DisplayState> displays;
3221     DisplayState d;
3222     d.what = DisplayState::eDisplayProjectionChanged |
3223              DisplayState::eLayerStackChanged;
3224     d.token = mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY];
3225     d.layerStack = 0;
3226     d.orientation = DisplayState::eOrientationDefault;
3227     d.frame.makeInvalid();
3228     d.viewport.makeInvalid();
3229     d.width = 0;
3230     d.height = 0;
3231     displays.add(d);
3232     setTransactionState(state, displays, 0);
3233     setPowerModeInternal(getDisplayDevice(d.token), HWC_POWER_MODE_NORMAL);
3234
3235     const auto& activeConfig = mHwc->getActiveConfig(HWC_DISPLAY_PRIMARY);
3236     const nsecs_t period = activeConfig->getVsyncPeriod();
3237     mAnimFrameTracker.setDisplayRefreshPeriod(period);
3238
3239     // Use phase of 0 since phase is not known.
3240     // Use latency of 0, which will snap to the ideal latency.
3241     setCompositorTimingSnapped(0, period, 0);
3242 }
3243
3244 void SurfaceFlinger::initializeDisplays() {
3245     class MessageScreenInitialized : public MessageBase {
3246         SurfaceFlinger* flinger;
3247     public:
3248         explicit MessageScreenInitialized(SurfaceFlinger* flinger) : flinger(flinger) { }
3249         virtual bool handler() {
3250             flinger->onInitializeDisplays();
3251             return true;
3252         }
3253     };
3254     sp<MessageBase> msg = new MessageScreenInitialized(this);
3255     postMessageAsync(msg);  // we may be called from main thread, use async message
3256 }
3257
3258 void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& hw,
3259         int mode) {
3260     ALOGD("Set power mode=%d, type=%d flinger=%p", mode, hw->getDisplayType(),
3261             this);
3262     int32_t type = hw->getDisplayType();
3263     int currentMode = hw->getPowerMode();
3264
3265     if (mode == currentMode) {
3266         return;
3267     }
3268
3269     hw->setPowerMode(mode);
3270     if (type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
3271         ALOGW("Trying to set power mode for virtual display");
3272         return;
3273     }
3274
3275     if (mInterceptor.isEnabled()) {
3276         Mutex::Autolock _l(mStateLock);
3277         ssize_t idx = mCurrentState.displays.indexOfKey(hw->getDisplayToken());
3278         if (idx < 0) {
3279             ALOGW("Surface Interceptor SavePowerMode: invalid display token");
3280             return;
3281         }
3282         mInterceptor.savePowerModeUpdate(mCurrentState.displays.valueAt(idx).displayId, mode);
3283     }
3284
3285     if (currentMode == HWC_POWER_MODE_OFF) {
3286         // Turn on the display
3287         getHwComposer().setPowerMode(type, mode);
3288         if (type == DisplayDevice::DISPLAY_PRIMARY &&
3289             mode != HWC_POWER_MODE_DOZE_SUSPEND) {
3290             // FIXME: eventthread only knows about the main display right now
3291             mEventThread->onScreenAcquired();
3292             resyncToHardwareVsync(true);
3293         }
3294
3295         mVisibleRegionsDirty = true;
3296         mHasPoweredOff = true;
3297         repaintEverything();
3298
3299         struct sched_param param = {0};
3300         param.sched_priority = 1;
3301         if (sched_setscheduler(0, SCHED_FIFO, &param) != 0) {
3302             ALOGW("Couldn't set SCHED_FIFO on display on");
3303         }
3304     } else if (mode == HWC_POWER_MODE_OFF) {
3305         // Turn off the display
3306         struct sched_param param = {0};
3307         if (sched_setscheduler(0, SCHED_OTHER, &param) != 0) {
3308             ALOGW("Couldn't set SCHED_OTHER on display off");
3309         }
3310
3311         if (type == DisplayDevice::DISPLAY_PRIMARY) {
3312             disableHardwareVsync(true); // also cancels any in-progress resync
3313
3314             // FIXME: eventthread only knows about the main display right now
3315             mEventThread->onScreenReleased();
3316         }
3317
3318         getHwComposer().setPowerMode(type, mode);
3319         mVisibleRegionsDirty = true;
3320         // from this point on, SF will stop drawing on this display
3321     } else if (mode == HWC_POWER_MODE_DOZE ||
3322                mode == HWC_POWER_MODE_NORMAL) {
3323         // Update display while dozing
3324         getHwComposer().setPowerMode(type, mode);
3325         if (type == DisplayDevice::DISPLAY_PRIMARY) {
3326             // FIXME: eventthread only knows about the main display right now
3327             mEventThread->onScreenAcquired();
3328             resyncToHardwareVsync(true);
3329         }
3330     } else if (mode == HWC_POWER_MODE_DOZE_SUSPEND) {
3331         // Leave display going to doze
3332         if (type == DisplayDevice::DISPLAY_PRIMARY) {
3333             disableHardwareVsync(true); // also cancels any in-progress resync
3334             // FIXME: eventthread only knows about the main display right now
3335             mEventThread->onScreenReleased();
3336         }
3337         getHwComposer().setPowerMode(type, mode);
3338     } else {
3339         ALOGE("Attempting to set unknown power mode: %d\n", mode);
3340         getHwComposer().setPowerMode(type, mode);
3341     }
3342 }
3343
3344 void SurfaceFlinger::setPowerMode(const sp<IBinder>& display, int mode) {
3345     class MessageSetPowerMode: public MessageBase {
3346         SurfaceFlinger& mFlinger;
3347         sp<IBinder> mDisplay;
3348         int mMode;
3349     public:
3350         MessageSetPowerMode(SurfaceFlinger& flinger,
3351                 const sp<IBinder>& disp, int mode) : mFlinger(flinger),
3352                     mDisplay(disp) { mMode = mode; }
3353         virtual bool handler() {
3354             sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay));
3355             if (hw == NULL) {
3356                 ALOGE("Attempt to set power mode = %d for null display %p",
3357                         mMode, mDisplay.get());
3358             } else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) {
3359                 ALOGW("Attempt to set power mode = %d for virtual display",
3360                         mMode);
3361             } else {
3362                 mFlinger.setPowerModeInternal(hw, mMode);
3363             }
3364             return true;
3365         }
3366     };
3367     sp<MessageBase> msg = new MessageSetPowerMode(*this, display, mode);
3368     postMessageSync(msg);
3369 }
3370
3371 // ---------------------------------------------------------------------------
3372
3373 status_t SurfaceFlinger::dump(int fd, const Vector<String16>& args)
3374 {
3375     String8 result;
3376
3377     IPCThreadState* ipc = IPCThreadState::self();
3378     const int pid = ipc->getCallingPid();
3379     const int uid = ipc->getCallingUid();
3380     if ((uid != AID_SHELL) &&
3381             !PermissionCache::checkPermission(sDump, pid, uid)) {
3382         result.appendFormat("Permission Denial: "
3383                 "can't dump SurfaceFlinger from pid=%d, uid=%d\n", pid, uid);
3384     } else {
3385         // Try to get the main lock, but give up after one second
3386         // (this would indicate SF is stuck, but we want to be able to
3387         // print something in dumpsys).
3388         status_t err = mStateLock.timedLock(s2ns(1));
3389         bool locked = (err == NO_ERROR);
3390         if (!locked) {
3391             result.appendFormat(
3392                     "SurfaceFlinger appears to be unresponsive (%s [%d]), "
3393                     "dumping anyways (no locks held)\n", strerror(-err), err);
3394         }
3395
3396         bool dumpAll = true;
3397         size_t index = 0;
3398         size_t numArgs = args.size();
3399         if (numArgs) {
3400             if ((index < numArgs) &&
3401                     (args[index] == String16("--list"))) {
3402                 index++;
3403                 listLayersLocked(args, index, result);
3404                 dumpAll = false;
3405             }
3406
3407             if ((index < numArgs) &&
3408                     (args[index] == String16("--latency"))) {
3409                 index++;
3410                 dumpStatsLocked(args, index, result);
3411                 dumpAll = false;
3412             }
3413
3414             if ((index < numArgs) &&
3415                     (args[index] == String16("--latency-clear"))) {
3416                 index++;
3417                 clearStatsLocked(args, index, result);
3418                 dumpAll = false;
3419             }
3420
3421             if ((index < numArgs) &&
3422                     (args[index] == String16("--dispsync"))) {
3423                 index++;
3424                 mPrimaryDispSync.dump(result);
3425                 dumpAll = false;
3426             }
3427
3428             if ((index < numArgs) &&
3429                     (args[index] == String16("--static-screen"))) {
3430                 index++;
3431                 dumpStaticScreenStats(result);
3432                 dumpAll = false;
3433             }
3434
3435             if ((index < numArgs) &&
3436                     (args[index] == String16("--frame-events"))) {
3437                 index++;
3438                 dumpFrameEventsLocked(result);
3439                 dumpAll = false;
3440             }
3441
3442             if ((index < numArgs) && (args[index] == String16("--wide-color"))) {
3443                 index++;
3444                 dumpWideColorInfo(result);
3445                 dumpAll = false;
3446             }
3447         }
3448
3449         if (dumpAll) {
3450             dumpAllLocked(args, index, result);
3451         }
3452
3453         if (locked) {
3454             mStateLock.unlock();
3455         }
3456     }
3457     write(fd, result.string(), result.size());
3458     return NO_ERROR;
3459 }
3460
3461 void SurfaceFlinger::listLayersLocked(const Vector<String16>& /* args */,
3462         size_t& /* index */, String8& result) const
3463 {
3464     mCurrentState.traverseInZOrder([&](Layer* layer) {
3465         result.appendFormat("%s\n", layer->getName().string());
3466     });
3467 }
3468
3469 void SurfaceFlinger::dumpStatsLocked(const Vector<String16>& args, size_t& index,
3470         String8& result) const
3471 {
3472     String8 name;
3473     if (index < args.size()) {
3474         name = String8(args[index]);
3475         index++;
3476     }
3477
3478     const auto& activeConfig = mHwc->getActiveConfig(HWC_DISPLAY_PRIMARY);
3479     const nsecs_t period = activeConfig->getVsyncPeriod();
3480     result.appendFormat("%" PRId64 "\n", period);
3481
3482     if (name.isEmpty()) {
3483         mAnimFrameTracker.dumpStats(result);
3484     } else {
3485         mCurrentState.traverseInZOrder([&](Layer* layer) {
3486             if (name == layer->getName()) {
3487                 layer->dumpFrameStats(result);
3488             }
3489         });
3490     }
3491 }
3492
3493 void SurfaceFlinger::clearStatsLocked(const Vector<String16>& args, size_t& index,
3494         String8& /* result */)
3495 {
3496     String8 name;
3497     if (index < args.size()) {
3498         name = String8(args[index]);
3499         index++;
3500     }
3501
3502     mCurrentState.traverseInZOrder([&](Layer* layer) {
3503         if (name.isEmpty() || (name == layer->getName())) {
3504             layer->clearFrameStats();
3505         }
3506     });
3507
3508     mAnimFrameTracker.clearStats();
3509 }
3510
3511 // This should only be called from the main thread.  Otherwise it would need
3512 // the lock and should use mCurrentState rather than mDrawingState.
3513 void SurfaceFlinger::logFrameStats() {
3514     mDrawingState.traverseInZOrder([&](Layer* layer) {
3515         layer->logFrameStats();
3516     });
3517
3518     mAnimFrameTracker.logAndResetStats(String8("<win-anim>"));
3519 }
3520
3521 void SurfaceFlinger::appendSfConfigString(String8& result) const
3522 {
3523     result.append(" [sf");
3524     result.appendFormat(" HAS_CONTEXT_PRIORITY=%d", useContextPriority);
3525
3526     if (isLayerTripleBufferingDisabled())
3527         result.append(" DISABLE_TRIPLE_BUFFERING");
3528
3529     result.appendFormat(" PRESENT_TIME_OFFSET=%" PRId64 , dispSyncPresentTimeOffset);
3530     result.appendFormat(" FORCE_HWC_FOR_RBG_TO_YUV=%d", useHwcForRgbToYuv);
3531     result.appendFormat(" MAX_VIRT_DISPLAY_DIM=%" PRIu64, maxVirtualDisplaySize);
3532     result.appendFormat(" RUNNING_WITHOUT_SYNC_FRAMEWORK=%d", !hasSyncFramework);
3533     result.appendFormat(" NUM_FRAMEBUFFER_SURFACE_BUFFERS=%" PRId64,
3534                         maxFrameBufferAcquiredBuffers);
3535     result.append("]");
3536 }
3537
3538 void SurfaceFlinger::dumpStaticScreenStats(String8& result) const
3539 {
3540     result.appendFormat("Static screen stats:\n");
3541     for (size_t b = 0; b < NUM_BUCKETS - 1; ++b) {
3542         float bucketTimeSec = mFrameBuckets[b] / 1e9;
3543         float percent = 100.0f *
3544                 static_cast<float>(mFrameBuckets[b]) / mTotalTime;
3545         result.appendFormat("  < %zd frames: %.3f s (%.1f%%)\n",
3546                 b + 1, bucketTimeSec, percent);
3547     }
3548     float bucketTimeSec = mFrameBuckets[NUM_BUCKETS - 1] / 1e9;
3549     float percent = 100.0f *
3550             static_cast<float>(mFrameBuckets[NUM_BUCKETS - 1]) / mTotalTime;
3551     result.appendFormat("  %zd+ frames: %.3f s (%.1f%%)\n",
3552             NUM_BUCKETS - 1, bucketTimeSec, percent);
3553 }
3554
3555 void SurfaceFlinger::recordBufferingStats(const char* layerName,
3556         std::vector<OccupancyTracker::Segment>&& history) {
3557     Mutex::Autolock lock(mBufferingStatsMutex);
3558     auto& stats = mBufferingStats[layerName];
3559     for (const auto& segment : history) {
3560         if (!segment.usedThirdBuffer) {
3561             stats.twoBufferTime += segment.totalTime;
3562         }
3563         if (segment.occupancyAverage < 1.0f) {
3564             stats.doubleBufferedTime += segment.totalTime;
3565         } else if (segment.occupancyAverage < 2.0f) {
3566             stats.tripleBufferedTime += segment.totalTime;
3567         }
3568         ++stats.numSegments;
3569         stats.totalTime += segment.totalTime;
3570     }
3571 }
3572
3573 void SurfaceFlinger::dumpFrameEventsLocked(String8& result) {
3574     result.appendFormat("Layer frame timestamps:\n");
3575
3576     const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
3577     const size_t count = currentLayers.size();
3578     for (size_t i=0 ; i<count ; i++) {
3579         currentLayers[i]->dumpFrameEvents(result);
3580     }
3581 }
3582
3583 void SurfaceFlinger::dumpBufferingStats(String8& result) const {
3584     result.append("Buffering stats:\n");
3585     result.append("  [Layer name] <Active time> <Two buffer> "
3586             "<Double buffered> <Triple buffered>\n");
3587     Mutex::Autolock lock(mBufferingStatsMutex);
3588     typedef std::tuple<std::string, float, float, float> BufferTuple;
3589     std::map<float, BufferTuple, std::greater<float>> sorted;
3590     for (const auto& statsPair : mBufferingStats) {
3591         const char* name = statsPair.first.c_str();
3592         const BufferingStats& stats = statsPair.second;
3593         if (stats.numSegments == 0) {
3594             continue;
3595         }
3596         float activeTime = ns2ms(stats.totalTime) / 1000.0f;
3597         float twoBufferRatio = static_cast<float>(stats.twoBufferTime) /
3598                 stats.totalTime;
3599         float doubleBufferRatio = static_cast<float>(
3600                 stats.doubleBufferedTime) / stats.totalTime;
3601         float tripleBufferRatio = static_cast<float>(
3602                 stats.tripleBufferedTime) / stats.totalTime;
3603         sorted.insert({activeTime, {name, twoBufferRatio,
3604                 doubleBufferRatio, tripleBufferRatio}});
3605     }
3606     for (const auto& sortedPair : sorted) {
3607         float activeTime = sortedPair.first;
3608         const BufferTuple& values = sortedPair.second;
3609         result.appendFormat("  [%s] %.2f %.3f %.3f %.3f\n",
3610                 std::get<0>(values).c_str(), activeTime,
3611                 std::get<1>(values), std::get<2>(values),
3612                 std::get<3>(values));
3613     }
3614     result.append("\n");
3615 }
3616
3617 void SurfaceFlinger::dumpWideColorInfo(String8& result) const {
3618     result.appendFormat("hasWideColorDisplay: %d\n", hasWideColorDisplay);
3619
3620     // TODO: print out if wide-color mode is active or not
3621
3622     for (size_t d = 0; d < mDisplays.size(); d++) {
3623         const sp<const DisplayDevice>& displayDevice(mDisplays[d]);
3624         int32_t hwcId = displayDevice->getHwcDisplayId();
3625         if (hwcId == DisplayDevice::DISPLAY_ID_INVALID) {
3626             continue;
3627         }
3628
3629         result.appendFormat("Display %d color modes:\n", hwcId);
3630         std::vector<android_color_mode_t> modes = getHwComposer().getColorModes(hwcId);
3631         for (auto&& mode : modes) {
3632             result.appendFormat("    %s (%d)\n", decodeColorMode(mode).c_str(), mode);
3633         }
3634
3635         android_color_mode_t currentMode = displayDevice->getActiveColorMode();
3636         result.appendFormat("    Current color mode: %s (%d)\n",
3637                             decodeColorMode(currentMode).c_str(), currentMode);
3638     }
3639     result.append("\n");
3640 }
3641
3642 void SurfaceFlinger::dumpAllLocked(const Vector<String16>& args, size_t& index,
3643         String8& result) const
3644 {
3645     bool colorize = false;
3646     if (index < args.size()
3647             && (args[index] == String16("--color"))) {
3648         colorize = true;
3649         index++;
3650     }
3651
3652     Colorizer colorizer(colorize);
3653
3654     // figure out if we're stuck somewhere
3655     const nsecs_t now = systemTime();
3656     const nsecs_t inSwapBuffers(mDebugInSwapBuffers);
3657     const nsecs_t inTransaction(mDebugInTransaction);
3658     nsecs_t inSwapBuffersDuration = (inSwapBuffers) ? now-inSwapBuffers : 0;
3659     nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
3660
3661     /*
3662      * Dump library configuration.
3663      */
3664
3665     colorizer.bold(result);
3666     result.append("Build configuration:");
3667     colorizer.reset(result);
3668     appendSfConfigString(result);
3669     appendUiConfigString(result);
3670     appendGuiConfigString(result);
3671     result.append("\n");
3672
3673     result.append("\nWide-Color information:\n");
3674     dumpWideColorInfo(result);
3675
3676     colorizer.bold(result);
3677     result.append("Sync configuration: ");
3678     colorizer.reset(result);
3679     result.append(SyncFeatures::getInstance().toString());
3680     result.append("\n");
3681
3682     const auto& activeConfig = mHwc->getActiveConfig(HWC_DISPLAY_PRIMARY);
3683
3684     colorizer.bold(result);
3685     result.append("DispSync configuration: ");
3686     colorizer.reset(result);
3687     result.appendFormat("app phase %" PRId64 " ns, sf phase %" PRId64 " ns, "
3688             "present offset %" PRId64 " ns (refresh %" PRId64 " ns)",
3689         vsyncPhaseOffsetNs, sfVsyncPhaseOffsetNs,
3690         dispSyncPresentTimeOffset, activeConfig->getVsyncPeriod());
3691     result.append("\n");
3692
3693     // Dump static screen stats
3694     result.append("\n");
3695     dumpStaticScreenStats(result);
3696     result.append("\n");
3697
3698     dumpBufferingStats(result);
3699
3700     /*
3701      * Dump the visible layer list
3702      */
3703     colorizer.bold(result);
3704     result.appendFormat("Visible layers (count = %zu)\n", mNumLayers);
3705     colorizer.reset(result);
3706     mCurrentState.traverseInZOrder([&](Layer* layer) {
3707         layer->dump(result, colorizer);
3708     });
3709
3710     /*
3711      * Dump Display state
3712      */
3713
3714     colorizer.bold(result);
3715     result.appendFormat("Displays (%zu entries)\n", mDisplays.size());
3716     colorizer.reset(result);
3717     for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
3718         const sp<const DisplayDevice>& hw(mDisplays[dpy]);
3719         hw->dump(result);
3720     }
3721
3722     /*
3723      * Dump SurfaceFlinger global state
3724      */
3725
3726     colorizer.bold(result);
3727     result.append("SurfaceFlinger global state:\n");
3728     colorizer.reset(result);
3729
3730     HWComposer& hwc(getHwComposer());
3731     sp<const DisplayDevice> hw(getDefaultDisplayDeviceLocked());
3732
3733     colorizer.bold(result);
3734     result.appendFormat("EGL implementation : %s\n",
3735             eglQueryStringImplementationANDROID(mEGLDisplay, EGL_VERSION));
3736     colorizer.reset(result);
3737     result.appendFormat("%s\n",
3738             eglQueryStringImplementationANDROID(mEGLDisplay, EGL_EXTENSIONS));
3739
3740     mRenderEngine->dump(result);
3741
3742     hw->undefinedRegion.dump(result, "undefinedRegion");
3743     result.appendFormat("  orientation=%d, isDisplayOn=%d\n",
3744             hw->getOrientation(), hw->isDisplayOn());
3745     result.appendFormat(
3746             "  last eglSwapBuffers() time: %f us\n"
3747             "  last transaction time     : %f us\n"
3748             "  transaction-flags         : %08x\n"
3749             "  refresh-rate              : %f fps\n"
3750             "  x-dpi                     : %f\n"
3751             "  y-dpi                     : %f\n"
3752             "  gpu_to_cpu_unsupported    : %d\n"
3753             ,
3754             mLastSwapBufferTime/1000.0,
3755             mLastTransactionTime/1000.0,
3756             mTransactionFlags,
3757             1e9 / activeConfig->getVsyncPeriod(),
3758             activeConfig->getDpiX(),
3759             activeConfig->getDpiY(),
3760             !mGpuToCpuSupported);
3761
3762     result.appendFormat("  eglSwapBuffers time: %f us\n",
3763             inSwapBuffersDuration/1000.0);
3764
3765     result.appendFormat("  transaction time: %f us\n",
3766             inTransactionDuration/1000.0);
3767
3768     /*
3769      * VSYNC state
3770      */
3771     mEventThread->dump(result);
3772     result.append("\n");
3773
3774     /*
3775      * HWC layer minidump
3776      */
3777     for (size_t d = 0; d < mDisplays.size(); d++) {
3778         const sp<const DisplayDevice>& displayDevice(mDisplays[d]);
3779         int32_t hwcId = displayDevice->getHwcDisplayId();
3780         if (hwcId == DisplayDevice::DISPLAY_ID_INVALID) {
3781             continue;
3782         }
3783
3784         result.appendFormat("Display %d HWC layers:\n", hwcId);
3785         Layer::miniDumpHeader(result);
3786         mCurrentState.traverseInZOrder([&](Layer* layer) {
3787             layer->miniDump(result, hwcId);
3788         });
3789         result.append("\n");
3790     }
3791
3792     /*
3793      * Dump HWComposer state
3794      */
3795     colorizer.bold(result);
3796     result.append("h/w composer state:\n");
3797     colorizer.reset(result);
3798     bool hwcDisabled = mDebugDisableHWC || mDebugRegion;
3799     result.appendFormat("  h/w composer %s\n",
3800             hwcDisabled ? "disabled" : "enabled");
3801     hwc.dump(result);
3802
3803     /*
3804      * Dump gralloc state
3805      */
3806     const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
3807     alloc.dump(result);
3808
3809     /*
3810      * Dump VrFlinger state if in use.
3811      */
3812     if (mVrFlingerRequestsDisplay && mVrFlinger) {
3813         result.append("VrFlinger state:\n");
3814         result.append(mVrFlinger->Dump().c_str());
3815         result.append("\n");
3816     }
3817 }
3818
3819 const Vector< sp<Layer> >&
3820 SurfaceFlinger::getLayerSortedByZForHwcDisplay(int id) {
3821     // Note: mStateLock is held here
3822     wp<IBinder> dpy;
3823     for (size_t i=0 ; i<mDisplays.size() ; i++) {
3824         if (mDisplays.valueAt(i)->getHwcDisplayId() == id) {
3825             dpy = mDisplays.keyAt(i);
3826             break;
3827         }
3828     }
3829     if (dpy == NULL) {
3830         ALOGE("getLayerSortedByZForHwcDisplay: invalid hwc display id %d", id);
3831         // Just use the primary display so we have something to return
3832         dpy = getBuiltInDisplay(DisplayDevice::DISPLAY_PRIMARY);
3833     }
3834     return getDisplayDeviceLocked(dpy)->getVisibleLayersSortedByZ();
3835 }
3836
3837 bool SurfaceFlinger::startDdmConnection()
3838 {
3839     void* libddmconnection_dso =
3840             dlopen("libsurfaceflinger_ddmconnection.so", RTLD_NOW);
3841     if (!libddmconnection_dso) {
3842         return false;
3843     }
3844     void (*DdmConnection_start)(const char* name);
3845     DdmConnection_start =
3846             (decltype(DdmConnection_start))dlsym(libddmconnection_dso, "DdmConnection_start");
3847     if (!DdmConnection_start) {
3848         dlclose(libddmconnection_dso);
3849         return false;
3850     }
3851     (*DdmConnection_start)(getServiceName());
3852     return true;
3853 }
3854
3855 status_t SurfaceFlinger::CheckTransactCodeCredentials(uint32_t code) {
3856     switch (code) {
3857         case CREATE_CONNECTION:
3858         case CREATE_DISPLAY:
3859         case BOOT_FINISHED:
3860         case CLEAR_ANIMATION_FRAME_STATS:
3861         case GET_ANIMATION_FRAME_STATS:
3862         case SET_POWER_MODE:
3863         case GET_HDR_CAPABILITIES:
3864         {
3865             // codes that require permission check
3866             IPCThreadState* ipc = IPCThreadState::self();
3867             const int pid = ipc->getCallingPid();
3868             const int uid = ipc->getCallingUid();
3869             if ((uid != AID_GRAPHICS && uid != AID_SYSTEM) &&
3870                     !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)) {
3871                 ALOGE("Permission Denial: can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
3872                 return PERMISSION_DENIED;
3873             }
3874             break;
3875         }
3876         /*
3877          * Calling setTransactionState is safe, because you need to have been
3878          * granted a reference to Client* and Handle* to do anything with it.
3879          *
3880          * Creating a scoped connection is safe, as per discussion in ISurfaceComposer.h
3881          */
3882         case SET_TRANSACTION_STATE:
3883         case CREATE_SCOPED_CONNECTION:
3884         {
3885             return OK;
3886         }
3887         case CAPTURE_SCREEN:
3888         {
3889             // codes that require permission check
3890             IPCThreadState* ipc = IPCThreadState::self();
3891             const int pid = ipc->getCallingPid();
3892             const int uid = ipc->getCallingUid();
3893             if ((uid != AID_GRAPHICS) &&
3894                     !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
3895                 ALOGE("Permission Denial: can't read framebuffer pid=%d, uid=%d", pid, uid);
3896                 return PERMISSION_DENIED;
3897             }
3898             break;
3899         }
3900     }
3901     return OK;
3902 }
3903
3904 status_t SurfaceFlinger::onTransact(
3905     uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
3906 {
3907     status_t credentialCheck = CheckTransactCodeCredentials(code);
3908     if (credentialCheck != OK) {
3909         return credentialCheck;
3910     }
3911
3912     status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
3913     if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
3914         CHECK_INTERFACE(ISurfaceComposer, data, reply);
3915         IPCThreadState* ipc = IPCThreadState::self();
3916         const int uid = ipc->getCallingUid();
3917         if (CC_UNLIKELY(uid != AID_SYSTEM
3918                 && !PermissionCache::checkCallingPermission(sHardwareTest))) {
3919             const int pid = ipc->getCallingPid();
3920             ALOGE("Permission Denial: "
3921                     "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
3922             return PERMISSION_DENIED;
3923         }
3924         int n;
3925         switch (code) {
3926             case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
3927             case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE
3928                 return NO_ERROR;
3929             case 1002:  // SHOW_UPDATES
3930                 n = data.readInt32();
3931                 mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
3932                 invalidateHwcGeometry();
3933                 repaintEverything();
3934                 return NO_ERROR;
3935             case 1004:{ // repaint everything
3936                 repaintEverything();
3937                 return NO_ERROR;
3938             }
3939             case 1005:{ // force transaction
3940                 setTransactionFlags(
3941                         eTransactionNeeded|
3942                         eDisplayTransactionNeeded|
3943                         eTraversalNeeded);
3944                 return NO_ERROR;
3945             }
3946             case 1006:{ // send empty update
3947                 signalRefresh();
3948                 return NO_ERROR;
3949             }
3950             case 1008:  // toggle use of hw composer
3951                 n = data.readInt32();
3952                 mDebugDisableHWC = n ? 1 : 0;
3953                 invalidateHwcGeometry();
3954                 repaintEverything();
3955                 return NO_ERROR;
3956             case 1009:  // toggle use of transform hint
3957                 n = data.readInt32();
3958                 mDebugDisableTransformHint = n ? 1 : 0;
3959                 invalidateHwcGeometry();
3960                 repaintEverything();
3961                 return NO_ERROR;
3962             case 1010:  // interrogate.
3963                 reply->writeInt32(0);
3964                 reply->writeInt32(0);
3965                 reply->writeInt32(mDebugRegion);
3966                 reply->writeInt32(0);
3967                 reply->writeInt32(mDebugDisableHWC);
3968                 return NO_ERROR;
3969             case 1013: {
3970                 sp<const DisplayDevice> hw(getDefaultDisplayDevice());
3971                 reply->writeInt32(hw->getPageFlipCount());
3972                 return NO_ERROR;
3973             }
3974             case 1014: {
3975                 // daltonize
3976                 n = data.readInt32();
3977                 switch (n % 10) {
3978                     case 1:
3979                         mDaltonizer.setType(ColorBlindnessType::Protanomaly);
3980                         break;
3981                     case 2:
3982                         mDaltonizer.setType(ColorBlindnessType::Deuteranomaly);
3983                         break;
3984                     case 3:
3985                         mDaltonizer.setType(ColorBlindnessType::Tritanomaly);
3986                         break;
3987                     default:
3988                         mDaltonizer.setType(ColorBlindnessType::None);
3989                         break;
3990                 }
3991                 if (n >= 10) {
3992                     mDaltonizer.setMode(ColorBlindnessMode::Correction);
3993                 } else {
3994                     mDaltonizer.setMode(ColorBlindnessMode::Simulation);
3995                 }
3996                 invalidateHwcGeometry();
3997                 repaintEverything();
3998                 return NO_ERROR;
3999             }
4000             case 1015: {
4001                 // apply a color matrix
4002                 n = data.readInt32();
4003                 if (n) {
4004                     // color matrix is sent as a column-major mat4 matrix
4005                     for (size_t i = 0 ; i < 4; i++) {
4006                         for (size_t j = 0; j < 4; j++) {
4007                             mColorMatrix[i][j] = data.readFloat();
4008                         }
4009                     }
4010                 } else {
4011                     mColorMatrix = mat4();
4012                 }
4013
4014                 // Check that supplied matrix's last row is {0,0,0,1} so we can avoid
4015                 // the division by w in the fragment shader
4016                 float4 lastRow(transpose(mColorMatrix)[3]);
4017                 if (any(greaterThan(abs(lastRow - float4{0, 0, 0, 1}), float4{1e-4f}))) {
4018                     ALOGE("The color transform's last row must be (0, 0, 0, 1)");
4019                 }
4020
4021                 invalidateHwcGeometry();
4022                 repaintEverything();
4023                 return NO_ERROR;
4024             }
4025             // This is an experimental interface
4026             // Needs to be shifted to proper binder interface when we productize
4027             case 1016: {
4028                 n = data.readInt32();
4029                 mPrimaryDispSync.setRefreshSkipCount(n);
4030                 return NO_ERROR;
4031             }
4032             case 1017: {
4033                 n = data.readInt32();
4034                 mForceFullDamage = static_cast<bool>(n);
4035                 return NO_ERROR;
4036             }
4037             case 1018: { // Modify Choreographer's phase offset
4038                 n = data.readInt32();
4039                 mEventThread->setPhaseOffset(static_cast<nsecs_t>(n));
4040                 return NO_ERROR;
4041             }
4042             case 1019: { // Modify SurfaceFlinger's phase offset
4043                 n = data.readInt32();
4044                 mSFEventThread->setPhaseOffset(static_cast<nsecs_t>(n));
4045                 return NO_ERROR;
4046             }
4047             case 1020: { // Layer updates interceptor
4048                 n = data.readInt32();
4049                 if (n) {
4050                     ALOGV("Interceptor enabled");
4051                     mInterceptor.enable(mDrawingState.layersSortedByZ, mDrawingState.displays);
4052                 }
4053                 else{
4054                     ALOGV("Interceptor disabled");
4055                     mInterceptor.disable();
4056                 }
4057                 return NO_ERROR;
4058             }
4059             case 1021: { // Disable HWC virtual displays
4060                 n = data.readInt32();
4061                 mUseHwcVirtualDisplays = !n;
4062                 return NO_ERROR;
4063             }
4064             case 1022: { // Set saturation boost
4065                 mSaturation = std::max(0.0f, std::min(data.readFloat(), 2.0f));
4066
4067                 invalidateHwcGeometry();
4068                 repaintEverything();
4069                 return NO_ERROR;
4070             }
4071         }
4072     }
4073     return err;
4074 }
4075
4076 void SurfaceFlinger::repaintEverything() {
4077     android_atomic_or(1, &mRepaintEverything);
4078     signalTransaction();
4079 }
4080
4081 // Checks that the requested width and height are valid and updates them to the display dimensions
4082 // if they are set to 0
4083 static status_t updateDimensionsLocked(const sp<const DisplayDevice>& displayDevice,
4084                                        Transform::orientation_flags rotation,
4085                                        uint32_t* requestedWidth, uint32_t* requestedHeight) {
4086     // get screen geometry
4087     uint32_t displayWidth = displayDevice->getWidth();
4088     uint32_t displayHeight = displayDevice->getHeight();
4089
4090     if (rotation & Transform::ROT_90) {
4091         std::swap(displayWidth, displayHeight);
4092     }
4093
4094     if ((*requestedWidth > displayWidth) || (*requestedHeight > displayHeight)) {
4095         ALOGE("size mismatch (%d, %d) > (%d, %d)",
4096                 *requestedWidth, *requestedHeight, displayWidth, displayHeight);
4097         return BAD_VALUE;
4098     }
4099
4100     if (*requestedWidth == 0) {
4101         *requestedWidth = displayWidth;
4102     }
4103     if (*requestedHeight == 0) {
4104         *requestedHeight = displayHeight;
4105     }
4106
4107     return NO_ERROR;
4108 }
4109
4110 // A simple RAII class to disconnect from an ANativeWindow* when it goes out of scope
4111 class WindowDisconnector {
4112 public:
4113     WindowDisconnector(ANativeWindow* window, int api) : mWindow(window), mApi(api) {}
4114     ~WindowDisconnector() {
4115         native_window_api_disconnect(mWindow, mApi);
4116     }
4117
4118 private:
4119     ANativeWindow* mWindow;
4120     const int mApi;
4121 };
4122
4123 static status_t getWindowBuffer(ANativeWindow* window, uint32_t requestedWidth,
4124                                 uint32_t requestedHeight, bool hasWideColorDisplay,
4125                                 bool renderEngineUsesWideColor, ANativeWindowBuffer** outBuffer) {
4126     const uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
4127             GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
4128
4129     int err = 0;
4130     err = native_window_set_buffers_dimensions(window, requestedWidth, requestedHeight);
4131     err |= native_window_set_scaling_mode(window, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
4132     err |= native_window_set_buffers_format(window, HAL_PIXEL_FORMAT_RGBA_8888);
4133     err |= native_window_set_usage(window, usage);
4134
4135     if (hasWideColorDisplay) {
4136         err |= native_window_set_buffers_data_space(window,
4137                                                     renderEngineUsesWideColor
4138                                                             ? HAL_DATASPACE_DISPLAY_P3
4139                                                             : HAL_DATASPACE_V0_SRGB);
4140     }
4141
4142     if (err != NO_ERROR) {
4143         return BAD_VALUE;
4144     }
4145
4146     /* TODO: Once we have the sync framework everywhere this can use
4147      * server-side waits on the fence that dequeueBuffer returns.
4148      */
4149     err = native_window_dequeue_buffer_and_wait(window, outBuffer);
4150     if (err != NO_ERROR) {
4151         return err;
4152     }
4153
4154     return NO_ERROR;
4155 }
4156
4157 status_t SurfaceFlinger::captureScreen(const sp<IBinder>& display,
4158         const sp<IGraphicBufferProducer>& producer,
4159         Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
4160         int32_t minLayerZ, int32_t maxLayerZ,
4161         bool useIdentityTransform, ISurfaceComposer::Rotation rotation) {
4162     ATRACE_CALL();
4163
4164     if (CC_UNLIKELY(display == 0))
4165         return BAD_VALUE;
4166
4167     if (CC_UNLIKELY(producer == 0))
4168         return BAD_VALUE;
4169
4170     // if we have secure windows on this display, never allow the screen capture
4171     // unless the producer interface is local (i.e.: we can take a screenshot for
4172     // ourselves).
4173     bool isLocalScreenshot = IInterface::asBinder(producer)->localBinder();
4174
4175     // Convert to surfaceflinger's internal rotation type.
4176     Transform::orientation_flags rotationFlags;
4177     switch (rotation) {
4178         case ISurfaceComposer::eRotateNone:
4179             rotationFlags = Transform::ROT_0;
4180             break;
4181         case ISurfaceComposer::eRotate90:
4182             rotationFlags = Transform::ROT_90;
4183             break;
4184         case ISurfaceComposer::eRotate180:
4185             rotationFlags = Transform::ROT_180;
4186             break;
4187         case ISurfaceComposer::eRotate270:
4188             rotationFlags = Transform::ROT_270;
4189             break;
4190         default:
4191             rotationFlags = Transform::ROT_0;
4192             ALOGE("Invalid rotation passed to captureScreen(): %d\n", rotation);
4193             break;
4194     }
4195
4196     { // Autolock scope
4197         Mutex::Autolock lock(mStateLock);
4198         sp<const DisplayDevice> displayDevice(getDisplayDeviceLocked(display));
4199         updateDimensionsLocked(displayDevice, rotationFlags, &reqWidth, &reqHeight);
4200     }
4201
4202     // create a surface (because we're a producer, and we need to
4203     // dequeue/queue a buffer)
4204     sp<Surface> surface = new Surface(producer, false);
4205
4206     // Put the screenshot Surface into async mode so that
4207     // Layer::headFenceHasSignaled will always return true and we'll latch the
4208     // first buffer regardless of whether or not its acquire fence has
4209     // signaled. This is needed to avoid a race condition in the rotation
4210     // animation. See b/30209608
4211     surface->setAsyncMode(true);
4212
4213     ANativeWindow* window = surface.get();
4214
4215     status_t result = native_window_api_connect(window, NATIVE_WINDOW_API_EGL);
4216     if (result != NO_ERROR) {
4217         return result;
4218     }
4219     WindowDisconnector disconnector(window, NATIVE_WINDOW_API_EGL);
4220
4221     ANativeWindowBuffer* buffer = nullptr;
4222     result = getWindowBuffer(window, reqWidth, reqHeight, hasWideColorDisplay,
4223                                       getRenderEngine().usesWideColor(), &buffer);
4224     if (result != NO_ERROR) {
4225         return result;
4226     }
4227
4228     // This mutex protects syncFd and captureResult for communication of the return values from the
4229     // main thread back to this Binder thread
4230     std::mutex captureMutex;
4231     std::condition_variable captureCondition;
4232     std::unique_lock<std::mutex> captureLock(captureMutex);
4233     int syncFd = -1;
4234     std::optional<status_t> captureResult;
4235
4236     sp<LambdaMessage> message = new LambdaMessage([&]() {
4237         // If there is a refresh pending, bug out early and tell the binder thread to try again
4238         // after the refresh.
4239         if (mRefreshPending) {
4240             ATRACE_NAME("Skipping screenshot for now");
4241             std::unique_lock<std::mutex> captureLock(captureMutex);
4242             captureResult = std::make_optional<status_t>(EAGAIN);
4243             captureCondition.notify_one();
4244             return;
4245         }
4246
4247         status_t result = NO_ERROR;
4248         int fd = -1;
4249         {
4250             Mutex::Autolock _l(mStateLock);
4251             sp<const DisplayDevice> device(getDisplayDeviceLocked(display));
4252             result = captureScreenImplLocked(device, buffer, sourceCrop, reqWidth, reqHeight,
4253                                              minLayerZ, maxLayerZ, useIdentityTransform,
4254                                              rotationFlags, isLocalScreenshot, &fd);
4255         }
4256
4257         {
4258             std::unique_lock<std::mutex> captureLock(captureMutex);
4259             syncFd = fd;
4260             captureResult = std::make_optional<status_t>(result);
4261             captureCondition.notify_one();
4262         }
4263     });
4264
4265     result = postMessageAsync(message);
4266     if (result == NO_ERROR) {
4267         captureCondition.wait(captureLock, [&]() { return captureResult; });
4268         while (*captureResult == EAGAIN) {
4269             captureResult.reset();
4270             result = postMessageAsync(message);
4271             if (result != NO_ERROR) {
4272                 return result;
4273             }
4274             captureCondition.wait(captureLock, [&]() { return captureResult; });
4275         }
4276         result = *captureResult;
4277     }
4278
4279     if (result == NO_ERROR) {
4280         // queueBuffer takes ownership of syncFd
4281         result = window->queueBuffer(window, buffer, syncFd);
4282     }
4283
4284     return result;
4285 }
4286
4287
4288 void SurfaceFlinger::renderScreenImplLocked(
4289         const sp<const DisplayDevice>& hw,
4290         Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
4291         int32_t minLayerZ, int32_t maxLayerZ,
4292         bool yswap, bool useIdentityTransform, Transform::orientation_flags rotation)
4293 {
4294     ATRACE_CALL();
4295     RenderEngine& engine(getRenderEngine());
4296
4297     // get screen geometry
4298     const int32_t hw_w = hw->getWidth();
4299     const int32_t hw_h = hw->getHeight();
4300     const bool filtering = static_cast<int32_t>(reqWidth) != hw_w ||
4301                            static_cast<int32_t>(reqHeight) != hw_h;
4302
4303     // if a default or invalid sourceCrop is passed in, set reasonable values
4304     if (sourceCrop.width() == 0 || sourceCrop.height() == 0 ||
4305             !sourceCrop.isValid()) {
4306         sourceCrop.setLeftTop(Point(0, 0));
4307         sourceCrop.setRightBottom(Point(hw_w, hw_h));
4308     }
4309
4310     // ensure that sourceCrop is inside screen
4311     if (sourceCrop.left < 0) {
4312         ALOGE("Invalid crop rect: l = %d (< 0)", sourceCrop.left);
4313     }
4314     if (sourceCrop.right > hw_w) {
4315         ALOGE("Invalid crop rect: r = %d (> %d)", sourceCrop.right, hw_w);
4316     }
4317     if (sourceCrop.top < 0) {
4318         ALOGE("Invalid crop rect: t = %d (< 0)", sourceCrop.top);
4319     }
4320     if (sourceCrop.bottom > hw_h) {
4321         ALOGE("Invalid crop rect: b = %d (> %d)", sourceCrop.bottom, hw_h);
4322     }
4323
4324 #ifdef USE_HWC2
4325      engine.setWideColor(hw->getWideColorSupport());
4326      engine.setColorMode(hw->getActiveColorMode());
4327 #endif
4328
4329     // make sure to clear all GL error flags
4330     engine.checkErrors();
4331
4332     // set-up our viewport
4333     engine.setViewportAndProjection(
4334         reqWidth, reqHeight, sourceCrop, hw_h, yswap, rotation);
4335     engine.disableTexturing();
4336
4337     // redraw the screen entirely...
4338     engine.clearWithColor(0, 0, 0, 1);
4339
4340     // We loop through the first level of layers without traversing,
4341     // as we need to interpret min/max layer Z in the top level Z space.
4342     for (const auto& layer : mDrawingState.layersSortedByZ) {
4343         if (!layer->belongsToDisplay(hw->getLayerStack(), false)) {
4344             continue;
4345         }
4346         const Layer::State& state(layer->getDrawingState());
4347         if (state.z < minLayerZ || state.z > maxLayerZ) {
4348             continue;
4349         }
4350         layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
4351             if (!layer->isVisible()) {
4352                 return;
4353             }
4354             if (filtering) layer->setFiltering(true);
4355             layer->draw(hw, useIdentityTransform);
4356             if (filtering) layer->setFiltering(false);
4357         });
4358     }
4359
4360     hw->setViewportAndProjection();
4361 }
4362
4363 // A simple RAII class that holds an EGLImage and destroys it either:
4364 //   a) When the destroy() method is called
4365 //   b) When the object goes out of scope
4366 class ImageHolder {
4367 public:
4368     ImageHolder(EGLDisplay display, EGLImageKHR image) : mDisplay(display), mImage(image) {}
4369     ~ImageHolder() { destroy(); }
4370
4371     void destroy() {
4372         if (mImage != EGL_NO_IMAGE_KHR) {
4373             eglDestroyImageKHR(mDisplay, mImage);
4374             mImage = EGL_NO_IMAGE_KHR;
4375         }
4376     }
4377
4378 private:
4379     const EGLDisplay mDisplay;
4380     EGLImageKHR mImage;
4381 };
4382
4383 status_t SurfaceFlinger::captureScreenImplLocked(const sp<const DisplayDevice>& hw,
4384                                                  ANativeWindowBuffer* buffer, Rect sourceCrop,
4385                                                  uint32_t reqWidth, uint32_t reqHeight,
4386                                                  int32_t minLayerZ, int32_t maxLayerZ,
4387                                                  bool useIdentityTransform,
4388                                                  Transform::orientation_flags rotation,
4389                                                  bool isLocalScreenshot, int* outSyncFd) {
4390     ATRACE_CALL();
4391
4392     bool secureLayerIsVisible = false;
4393     for (const auto& layer : mDrawingState.layersSortedByZ) {
4394         const Layer::State& state(layer->getDrawingState());
4395         if (layer->belongsToDisplay(hw->getLayerStack(), false) ||
4396                 (state.z < minLayerZ || state.z > maxLayerZ)) {
4397             continue;
4398         }
4399         layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer *layer) {
4400             secureLayerIsVisible = secureLayerIsVisible || (layer->isVisible() &&
4401                     layer->isSecure());
4402         });
4403     }
4404
4405     if (!isLocalScreenshot && secureLayerIsVisible) {
4406         ALOGW("FB is protected: PERMISSION_DENIED");
4407         return PERMISSION_DENIED;
4408     }
4409
4410     int syncFd = -1;
4411     // create an EGLImage from the buffer so we can later
4412     // turn it into a texture
4413     EGLImageKHR image = eglCreateImageKHR(mEGLDisplay, EGL_NO_CONTEXT,
4414             EGL_NATIVE_BUFFER_ANDROID, buffer, NULL);
4415     if (image == EGL_NO_IMAGE_KHR) {
4416         return BAD_VALUE;
4417     }
4418
4419     // This will automatically destroy the image if we return before calling its destroy method
4420     ImageHolder imageHolder(mEGLDisplay, image);
4421
4422     // this binds the given EGLImage as a framebuffer for the
4423     // duration of this scope.
4424     RenderEngine::BindImageAsFramebuffer imageBond(getRenderEngine(), image);
4425     if (imageBond.getStatus() != NO_ERROR) {
4426         ALOGE("got GL_FRAMEBUFFER_COMPLETE_OES error while taking screenshot");
4427         return INVALID_OPERATION;
4428     }
4429
4430     // this will in fact render into our dequeued buffer
4431     // via an FBO, which means we didn't have to create
4432     // an EGLSurface and therefore we're not
4433     // dependent on the context's EGLConfig.
4434     renderScreenImplLocked(
4435         hw, sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ, true,
4436         useIdentityTransform, rotation);
4437
4438     // Attempt to create a sync khr object that can produce a sync point. If that
4439     // isn't available, create a non-dupable sync object in the fallback path and
4440     // wait on it directly.
4441     EGLSyncKHR sync = EGL_NO_SYNC_KHR;
4442     if (!DEBUG_SCREENSHOTS) {
4443        sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, NULL);
4444        // native fence fd will not be populated until flush() is done.
4445        getRenderEngine().flush();
4446     }
4447
4448     if (sync != EGL_NO_SYNC_KHR) {
4449         // get the sync fd
4450         syncFd = eglDupNativeFenceFDANDROID(mEGLDisplay, sync);
4451         if (syncFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
4452             ALOGW("captureScreen: failed to dup sync khr object");
4453             syncFd = -1;
4454         }
4455         eglDestroySyncKHR(mEGLDisplay, sync);
4456     } else {
4457         // fallback path
4458         sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, NULL);
4459         if (sync != EGL_NO_SYNC_KHR) {
4460             EGLint result = eglClientWaitSyncKHR(mEGLDisplay, sync,
4461                 EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, 2000000000 /*2 sec*/);
4462             EGLint eglErr = eglGetError();
4463             if (result == EGL_TIMEOUT_EXPIRED_KHR) {
4464                 ALOGW("captureScreen: fence wait timed out");
4465             } else {
4466                 ALOGW_IF(eglErr != EGL_SUCCESS,
4467                         "captureScreen: error waiting on EGL fence: %#x", eglErr);
4468             }
4469             eglDestroySyncKHR(mEGLDisplay, sync);
4470         } else {
4471             ALOGW("captureScreen: error creating EGL fence: %#x", eglGetError());
4472         }
4473     }
4474     *outSyncFd = syncFd;
4475
4476     if (DEBUG_SCREENSHOTS) {
4477         uint32_t* pixels = new uint32_t[reqWidth*reqHeight];
4478         getRenderEngine().readPixels(0, 0, reqWidth, reqHeight, pixels);
4479         checkScreenshot(reqWidth, reqHeight, reqWidth, pixels,
4480                 hw, minLayerZ, maxLayerZ);
4481         delete [] pixels;
4482     }
4483
4484     // destroy our image
4485     imageHolder.destroy();
4486
4487     return NO_ERROR;
4488 }
4489
4490 void SurfaceFlinger::checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
4491         const sp<const DisplayDevice>& hw, int32_t minLayerZ, int32_t maxLayerZ) {
4492     if (DEBUG_SCREENSHOTS) {
4493         for (size_t y=0 ; y<h ; y++) {
4494             uint32_t const * p = (uint32_t const *)vaddr + y*s;
4495             for (size_t x=0 ; x<w ; x++) {
4496                 if (p[x] != 0xFF000000) return;
4497             }
4498         }
4499         ALOGE("*** we just took a black screenshot ***\n"
4500                 "requested minz=%d, maxz=%d, layerStack=%d",
4501                 minLayerZ, maxLayerZ, hw->getLayerStack());
4502
4503         size_t i = 0;
4504         for (const auto& layer : mDrawingState.layersSortedByZ) {
4505             const Layer::State& state(layer->getDrawingState());
4506             if (layer->belongsToDisplay(hw->getLayerStack(), false) && state.z >= minLayerZ &&
4507                     state.z <= maxLayerZ) {
4508                 layer->traverseInZOrder(LayerVector::StateSet::Drawing, [&](Layer* layer) {
4509                     ALOGE("%c index=%zu, name=%s, layerStack=%d, z=%d, visible=%d, flags=%x, alpha=%.3f",
4510                             layer->isVisible() ? '+' : '-',
4511                             i, layer->getName().string(), layer->getLayerStack(), state.z,
4512                             layer->isVisible(), state.flags, state.alpha);
4513                     i++;
4514                 });
4515             }
4516         }
4517     }
4518 }
4519
4520 // ---------------------------------------------------------------------------
4521
4522 void SurfaceFlinger::State::traverseInZOrder(const LayerVector::Visitor& visitor) const {
4523     layersSortedByZ.traverseInZOrder(stateSet, visitor);
4524 }
4525
4526 void SurfaceFlinger::State::traverseInReverseZOrder(const LayerVector::Visitor& visitor) const {
4527     layersSortedByZ.traverseInReverseZOrder(stateSet, visitor);
4528 }
4529
4530 }; // namespace android
4531
4532
4533 #if defined(__gl_h_)
4534 #error "don't include gl/gl.h in this file"
4535 #endif
4536
4537 #if defined(__gl2_h_)
4538 #error "don't include gl2/gl2.h in this file"
4539 #endif