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