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