services/surfaceflinger/SurfaceFlinger.cpp

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