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