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