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