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