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