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