services/surfaceflinger/SurfaceFlinger.cpp

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