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