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