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