SurfaceFlinger.cpp revision 41d67d7ab4da1c393497a620a116a854b3c618e7
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 colorizer.bold(result); 2375 result.append("DispSync configuration: "); 2376 colorizer.reset(result); 2377 result.appendFormat("app phase %"PRId64" ns, sf phase %"PRId64" ns, " 2378 "present offset %d ns (refresh %"PRId64" ns)", 2379 vsyncPhaseOffsetNs, sfVsyncPhaseOffsetNs, PRESENT_TIME_OFFSET_FROM_VSYNC_NS, 2380 mHwc->getRefreshPeriod(HWC_DISPLAY_PRIMARY)); 2381 result.append("\n"); 2382 2383 /* 2384 * Dump the visible layer list 2385 */ 2386 const LayerVector& currentLayers = mCurrentState.layersSortedByZ; 2387 const size_t count = currentLayers.size(); 2388 colorizer.bold(result); 2389 result.appendFormat("Visible layers (count = %zu)\n", count); 2390 colorizer.reset(result); 2391 for (size_t i=0 ; i<count ; i++) { 2392 const sp<Layer>& layer(currentLayers[i]); 2393 layer->dump(result, colorizer); 2394 } 2395 2396 /* 2397 * Dump Display state 2398 */ 2399 2400 colorizer.bold(result); 2401 result.appendFormat("Displays (%zu entries)\n", mDisplays.size()); 2402 colorizer.reset(result); 2403 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 2404 const sp<const DisplayDevice>& hw(mDisplays[dpy]); 2405 hw->dump(result); 2406 } 2407 2408 /* 2409 * Dump SurfaceFlinger global state 2410 */ 2411 2412 colorizer.bold(result); 2413 result.append("SurfaceFlinger global state:\n"); 2414 colorizer.reset(result); 2415 2416 HWComposer& hwc(getHwComposer()); 2417 sp<const DisplayDevice> hw(getDefaultDisplayDevice()); 2418 2419 colorizer.bold(result); 2420 result.appendFormat("EGL implementation : %s\n", 2421 eglQueryStringImplementationANDROID(mEGLDisplay, EGL_VERSION)); 2422 colorizer.reset(result); 2423 result.appendFormat("%s\n", 2424 eglQueryStringImplementationANDROID(mEGLDisplay, EGL_EXTENSIONS)); 2425 2426 mRenderEngine->dump(result); 2427 2428 hw->undefinedRegion.dump(result, "undefinedRegion"); 2429 result.appendFormat(" orientation=%d, canDraw=%d\n", 2430 hw->getOrientation(), hw->canDraw()); 2431 result.appendFormat( 2432 " last eglSwapBuffers() time: %f us\n" 2433 " last transaction time : %f us\n" 2434 " transaction-flags : %08x\n" 2435 " refresh-rate : %f fps\n" 2436 " x-dpi : %f\n" 2437 " y-dpi : %f\n" 2438 " gpu_to_cpu_unsupported : %d\n" 2439 , 2440 mLastSwapBufferTime/1000.0, 2441 mLastTransactionTime/1000.0, 2442 mTransactionFlags, 2443 1e9 / hwc.getRefreshPeriod(HWC_DISPLAY_PRIMARY), 2444 hwc.getDpiX(HWC_DISPLAY_PRIMARY), 2445 hwc.getDpiY(HWC_DISPLAY_PRIMARY), 2446 !mGpuToCpuSupported); 2447 2448 result.appendFormat(" eglSwapBuffers time: %f us\n", 2449 inSwapBuffersDuration/1000.0); 2450 2451 result.appendFormat(" transaction time: %f us\n", 2452 inTransactionDuration/1000.0); 2453 2454 /* 2455 * VSYNC state 2456 */ 2457 mEventThread->dump(result); 2458 2459 /* 2460 * Dump HWComposer state 2461 */ 2462 colorizer.bold(result); 2463 result.append("h/w composer state:\n"); 2464 colorizer.reset(result); 2465 result.appendFormat(" h/w composer %s and %s\n", 2466 hwc.initCheck()==NO_ERROR ? "present" : "not present", 2467 (mDebugDisableHWC || mDebugRegion || mDaltonize 2468 || mHasColorMatrix) ? "disabled" : "enabled"); 2469 hwc.dump(result); 2470 2471 /* 2472 * Dump gralloc state 2473 */ 2474 const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get()); 2475 alloc.dump(result); 2476} 2477 2478const Vector< sp<Layer> >& 2479SurfaceFlinger::getLayerSortedByZForHwcDisplay(int id) { 2480 // Note: mStateLock is held here 2481 wp<IBinder> dpy; 2482 for (size_t i=0 ; i<mDisplays.size() ; i++) { 2483 if (mDisplays.valueAt(i)->getHwcDisplayId() == id) { 2484 dpy = mDisplays.keyAt(i); 2485 break; 2486 } 2487 } 2488 if (dpy == NULL) { 2489 ALOGE("getLayerSortedByZForHwcDisplay: invalid hwc display id %d", id); 2490 // Just use the primary display so we have something to return 2491 dpy = getBuiltInDisplay(DisplayDevice::DISPLAY_PRIMARY); 2492 } 2493 return getDisplayDevice(dpy)->getVisibleLayersSortedByZ(); 2494} 2495 2496bool SurfaceFlinger::startDdmConnection() 2497{ 2498 void* libddmconnection_dso = 2499 dlopen("libsurfaceflinger_ddmconnection.so", RTLD_NOW); 2500 if (!libddmconnection_dso) { 2501 return false; 2502 } 2503 void (*DdmConnection_start)(const char* name); 2504 DdmConnection_start = 2505 (typeof DdmConnection_start)dlsym(libddmconnection_dso, "DdmConnection_start"); 2506 if (!DdmConnection_start) { 2507 dlclose(libddmconnection_dso); 2508 return false; 2509 } 2510 (*DdmConnection_start)(getServiceName()); 2511 return true; 2512} 2513 2514status_t SurfaceFlinger::onTransact( 2515 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 2516{ 2517 switch (code) { 2518 case CREATE_CONNECTION: 2519 case CREATE_DISPLAY: 2520 case SET_TRANSACTION_STATE: 2521 case BOOT_FINISHED: 2522 case BLANK: 2523 case UNBLANK: 2524 case CLEAR_ANIMATION_FRAME_STATS: 2525 case GET_ANIMATION_FRAME_STATS: 2526 { 2527 // codes that require permission check 2528 IPCThreadState* ipc = IPCThreadState::self(); 2529 const int pid = ipc->getCallingPid(); 2530 const int uid = ipc->getCallingUid(); 2531 if ((uid != AID_GRAPHICS) && 2532 !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)) { 2533 ALOGE("Permission Denial: " 2534 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid); 2535 return PERMISSION_DENIED; 2536 } 2537 break; 2538 } 2539 case CAPTURE_SCREEN: 2540 { 2541 // codes that require permission check 2542 IPCThreadState* ipc = IPCThreadState::self(); 2543 const int pid = ipc->getCallingPid(); 2544 const int uid = ipc->getCallingUid(); 2545 if ((uid != AID_GRAPHICS) && 2546 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) { 2547 ALOGE("Permission Denial: " 2548 "can't read framebuffer pid=%d, uid=%d", pid, uid); 2549 return PERMISSION_DENIED; 2550 } 2551 break; 2552 } 2553 } 2554 2555 status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags); 2556 if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) { 2557 CHECK_INTERFACE(ISurfaceComposer, data, reply); 2558 if (CC_UNLIKELY(!PermissionCache::checkCallingPermission(sHardwareTest))) { 2559 IPCThreadState* ipc = IPCThreadState::self(); 2560 const int pid = ipc->getCallingPid(); 2561 const int uid = ipc->getCallingUid(); 2562 ALOGE("Permission Denial: " 2563 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid); 2564 return PERMISSION_DENIED; 2565 } 2566 int n; 2567 switch (code) { 2568 case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE 2569 case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE 2570 return NO_ERROR; 2571 case 1002: // SHOW_UPDATES 2572 n = data.readInt32(); 2573 mDebugRegion = n ? n : (mDebugRegion ? 0 : 1); 2574 invalidateHwcGeometry(); 2575 repaintEverything(); 2576 return NO_ERROR; 2577 case 1004:{ // repaint everything 2578 repaintEverything(); 2579 return NO_ERROR; 2580 } 2581 case 1005:{ // force transaction 2582 setTransactionFlags( 2583 eTransactionNeeded| 2584 eDisplayTransactionNeeded| 2585 eTraversalNeeded); 2586 return NO_ERROR; 2587 } 2588 case 1006:{ // send empty update 2589 signalRefresh(); 2590 return NO_ERROR; 2591 } 2592 case 1008: // toggle use of hw composer 2593 n = data.readInt32(); 2594 mDebugDisableHWC = n ? 1 : 0; 2595 invalidateHwcGeometry(); 2596 repaintEverything(); 2597 return NO_ERROR; 2598 case 1009: // toggle use of transform hint 2599 n = data.readInt32(); 2600 mDebugDisableTransformHint = n ? 1 : 0; 2601 invalidateHwcGeometry(); 2602 repaintEverything(); 2603 return NO_ERROR; 2604 case 1010: // interrogate. 2605 reply->writeInt32(0); 2606 reply->writeInt32(0); 2607 reply->writeInt32(mDebugRegion); 2608 reply->writeInt32(0); 2609 reply->writeInt32(mDebugDisableHWC); 2610 return NO_ERROR; 2611 case 1013: { 2612 Mutex::Autolock _l(mStateLock); 2613 sp<const DisplayDevice> hw(getDefaultDisplayDevice()); 2614 reply->writeInt32(hw->getPageFlipCount()); 2615 return NO_ERROR; 2616 } 2617 case 1014: { 2618 // daltonize 2619 n = data.readInt32(); 2620 switch (n % 10) { 2621 case 1: mDaltonizer.setType(Daltonizer::protanomaly); break; 2622 case 2: mDaltonizer.setType(Daltonizer::deuteranomaly); break; 2623 case 3: mDaltonizer.setType(Daltonizer::tritanomaly); break; 2624 } 2625 if (n >= 10) { 2626 mDaltonizer.setMode(Daltonizer::correction); 2627 } else { 2628 mDaltonizer.setMode(Daltonizer::simulation); 2629 } 2630 mDaltonize = n > 0; 2631 invalidateHwcGeometry(); 2632 repaintEverything(); 2633 return NO_ERROR; 2634 } 2635 case 1015: { 2636 // apply a color matrix 2637 n = data.readInt32(); 2638 mHasColorMatrix = n ? 1 : 0; 2639 if (n) { 2640 // color matrix is sent as mat3 matrix followed by vec3 2641 // offset, then packed into a mat4 where the last row is 2642 // the offset and extra values are 0 2643 for (size_t i = 0 ; i < 4; i++) { 2644 for (size_t j = 0; j < 4; j++) { 2645 mColorMatrix[i][j] = data.readFloat(); 2646 } 2647 } 2648 } else { 2649 mColorMatrix = mat4(); 2650 } 2651 invalidateHwcGeometry(); 2652 repaintEverything(); 2653 return NO_ERROR; 2654 } 2655 // This is an experimental interface 2656 // Needs to be shifted to proper binder interface when we productize 2657 case 1016: { 2658 mPrimaryDispSync.setLowPowerMode(true); 2659 return NO_ERROR; 2660 } 2661 case 1017: { 2662 mPrimaryDispSync.setLowPowerMode(false); 2663 return NO_ERROR; 2664 } 2665 } 2666 } 2667 return err; 2668} 2669 2670void SurfaceFlinger::repaintEverything() { 2671 android_atomic_or(1, &mRepaintEverything); 2672 signalTransaction(); 2673} 2674 2675// --------------------------------------------------------------------------- 2676// Capture screen into an IGraphiBufferProducer 2677// --------------------------------------------------------------------------- 2678 2679/* The code below is here to handle b/8734824 2680 * 2681 * We create a IGraphicBufferProducer wrapper that forwards all calls 2682 * to the calling binder thread, where they are executed. This allows 2683 * the calling thread to be reused (on the other side) and not 2684 * depend on having "enough" binder threads to handle the requests. 2685 * 2686 */ 2687 2688class GraphicProducerWrapper : public BBinder, public MessageHandler { 2689 sp<IGraphicBufferProducer> impl; 2690 sp<Looper> looper; 2691 status_t result; 2692 bool exitPending; 2693 bool exitRequested; 2694 mutable Barrier barrier; 2695 volatile int32_t memoryBarrier; 2696 uint32_t code; 2697 Parcel const* data; 2698 Parcel* reply; 2699 2700 enum { 2701 MSG_API_CALL, 2702 MSG_EXIT 2703 }; 2704 2705 /* 2706 * this is called by our "fake" BpGraphicBufferProducer. We package the 2707 * data and reply Parcel and forward them to the calling thread. 2708 */ 2709 virtual status_t transact(uint32_t code, 2710 const Parcel& data, Parcel* reply, uint32_t /* flags */) { 2711 this->code = code; 2712 this->data = &data; 2713 this->reply = reply; 2714 android_atomic_acquire_store(0, &memoryBarrier); 2715 if (exitPending) { 2716 // if we've exited, we run the message synchronously right here 2717 handleMessage(Message(MSG_API_CALL)); 2718 } else { 2719 barrier.close(); 2720 looper->sendMessage(this, Message(MSG_API_CALL)); 2721 barrier.wait(); 2722 } 2723 return result; 2724 } 2725 2726 /* 2727 * here we run on the binder calling thread. All we've got to do is 2728 * call the real BpGraphicBufferProducer. 2729 */ 2730 virtual void handleMessage(const Message& message) { 2731 android_atomic_release_load(&memoryBarrier); 2732 if (message.what == MSG_API_CALL) { 2733 result = impl->asBinder()->transact(code, data[0], reply); 2734 barrier.open(); 2735 } else if (message.what == MSG_EXIT) { 2736 exitRequested = true; 2737 } 2738 } 2739 2740public: 2741 GraphicProducerWrapper(const sp<IGraphicBufferProducer>& impl) : 2742 impl(impl), looper(new Looper(true)), result(NO_ERROR), 2743 exitPending(false), exitRequested(false) { 2744 } 2745 2746 status_t waitForResponse() { 2747 do { 2748 looper->pollOnce(-1); 2749 } while (!exitRequested); 2750 return result; 2751 } 2752 2753 void exit(status_t result) { 2754 this->result = result; 2755 exitPending = true; 2756 looper->sendMessage(this, Message(MSG_EXIT)); 2757 } 2758}; 2759 2760 2761status_t SurfaceFlinger::captureScreen(const sp<IBinder>& display, 2762 const sp<IGraphicBufferProducer>& producer, 2763 uint32_t reqWidth, uint32_t reqHeight, 2764 uint32_t minLayerZ, uint32_t maxLayerZ, 2765 bool useIdentityTransform) { 2766 2767 if (CC_UNLIKELY(display == 0)) 2768 return BAD_VALUE; 2769 2770 if (CC_UNLIKELY(producer == 0)) 2771 return BAD_VALUE; 2772 2773 // if we have secure windows on this display, never allow the screen capture 2774 // unless the producer interface is local (i.e.: we can take a screenshot for 2775 // ourselves). 2776 if (!producer->asBinder()->localBinder()) { 2777 Mutex::Autolock _l(mStateLock); 2778 sp<const DisplayDevice> hw(getDisplayDevice(display)); 2779 if (hw->getSecureLayerVisible()) { 2780 ALOGW("FB is protected: PERMISSION_DENIED"); 2781 return PERMISSION_DENIED; 2782 } 2783 } 2784 2785 class MessageCaptureScreen : public MessageBase { 2786 SurfaceFlinger* flinger; 2787 sp<IBinder> display; 2788 sp<IGraphicBufferProducer> producer; 2789 uint32_t reqWidth, reqHeight; 2790 uint32_t minLayerZ,maxLayerZ; 2791 bool useIdentityTransform; 2792 status_t result; 2793 public: 2794 MessageCaptureScreen(SurfaceFlinger* flinger, 2795 const sp<IBinder>& display, 2796 const sp<IGraphicBufferProducer>& producer, 2797 uint32_t reqWidth, uint32_t reqHeight, 2798 uint32_t minLayerZ, uint32_t maxLayerZ, 2799 bool useIdentityTransform) 2800 : flinger(flinger), display(display), producer(producer), 2801 reqWidth(reqWidth), reqHeight(reqHeight), 2802 minLayerZ(minLayerZ), maxLayerZ(maxLayerZ), 2803 useIdentityTransform(useIdentityTransform), 2804 result(PERMISSION_DENIED) 2805 { 2806 } 2807 status_t getResult() const { 2808 return result; 2809 } 2810 virtual bool handler() { 2811 Mutex::Autolock _l(flinger->mStateLock); 2812 sp<const DisplayDevice> hw(flinger->getDisplayDevice(display)); 2813 result = flinger->captureScreenImplLocked(hw, producer, 2814 reqWidth, reqHeight, minLayerZ, maxLayerZ, 2815 useIdentityTransform); 2816 static_cast<GraphicProducerWrapper*>(producer->asBinder().get())->exit(result); 2817 return true; 2818 } 2819 }; 2820 2821 // make sure to process transactions before screenshots -- a transaction 2822 // might already be pending but scheduled for VSYNC; this guarantees we 2823 // will handle it before the screenshot. When VSYNC finally arrives 2824 // the scheduled transaction will be a no-op. If no transactions are 2825 // scheduled at this time, this will end-up being a no-op as well. 2826 mEventQueue.invalidateTransactionNow(); 2827 2828 // this creates a "fake" BBinder which will serve as a "fake" remote 2829 // binder to receive the marshaled calls and forward them to the 2830 // real remote (a BpGraphicBufferProducer) 2831 sp<GraphicProducerWrapper> wrapper = new GraphicProducerWrapper(producer); 2832 2833 // the asInterface() call below creates our "fake" BpGraphicBufferProducer 2834 // which does the marshaling work forwards to our "fake remote" above. 2835 sp<MessageBase> msg = new MessageCaptureScreen(this, 2836 display, IGraphicBufferProducer::asInterface( wrapper ), 2837 reqWidth, reqHeight, minLayerZ, maxLayerZ, useIdentityTransform); 2838 2839 status_t res = postMessageAsync(msg); 2840 if (res == NO_ERROR) { 2841 res = wrapper->waitForResponse(); 2842 } 2843 return res; 2844} 2845 2846 2847void SurfaceFlinger::renderScreenImplLocked( 2848 const sp<const DisplayDevice>& hw, 2849 uint32_t reqWidth, uint32_t reqHeight, 2850 uint32_t minLayerZ, uint32_t maxLayerZ, 2851 bool yswap, bool useIdentityTransform) 2852{ 2853 ATRACE_CALL(); 2854 RenderEngine& engine(getRenderEngine()); 2855 2856 // get screen geometry 2857 const uint32_t hw_w = hw->getWidth(); 2858 const uint32_t hw_h = hw->getHeight(); 2859 const bool filtering = reqWidth != hw_w || reqWidth != hw_h; 2860 2861 // make sure to clear all GL error flags 2862 engine.checkErrors(); 2863 2864 // set-up our viewport 2865 engine.setViewportAndProjection(reqWidth, reqHeight, hw_w, hw_h, yswap); 2866 engine.disableTexturing(); 2867 2868 // redraw the screen entirely... 2869 engine.clearWithColor(0, 0, 0, 1); 2870 2871 const LayerVector& layers( mDrawingState.layersSortedByZ ); 2872 const size_t count = layers.size(); 2873 for (size_t i=0 ; i<count ; ++i) { 2874 const sp<Layer>& layer(layers[i]); 2875 const Layer::State& state(layer->getDrawingState()); 2876 if (state.layerStack == hw->getLayerStack()) { 2877 if (state.z >= minLayerZ && state.z <= maxLayerZ) { 2878 if (layer->isVisible()) { 2879 if (filtering) layer->setFiltering(true); 2880 layer->draw(hw, useIdentityTransform); 2881 if (filtering) layer->setFiltering(false); 2882 } 2883 } 2884 } 2885 } 2886 2887 // compositionComplete is needed for older driver 2888 hw->compositionComplete(); 2889 hw->setViewportAndProjection(); 2890} 2891 2892 2893status_t SurfaceFlinger::captureScreenImplLocked( 2894 const sp<const DisplayDevice>& hw, 2895 const sp<IGraphicBufferProducer>& producer, 2896 uint32_t reqWidth, uint32_t reqHeight, 2897 uint32_t minLayerZ, uint32_t maxLayerZ, 2898 bool useIdentityTransform) 2899{ 2900 ATRACE_CALL(); 2901 2902 // get screen geometry 2903 const uint32_t hw_w = hw->getWidth(); 2904 const uint32_t hw_h = hw->getHeight(); 2905 2906 if ((reqWidth > hw_w) || (reqHeight > hw_h)) { 2907 ALOGE("size mismatch (%d, %d) > (%d, %d)", 2908 reqWidth, reqHeight, hw_w, hw_h); 2909 return BAD_VALUE; 2910 } 2911 2912 reqWidth = (!reqWidth) ? hw_w : reqWidth; 2913 reqHeight = (!reqHeight) ? hw_h : reqHeight; 2914 2915 // create a surface (because we're a producer, and we need to 2916 // dequeue/queue a buffer) 2917 sp<Surface> sur = new Surface(producer, false); 2918 ANativeWindow* window = sur.get(); 2919 2920 status_t result = NO_ERROR; 2921 if (native_window_api_connect(window, NATIVE_WINDOW_API_EGL) == NO_ERROR) { 2922 uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN | 2923 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE; 2924 2925 int err = 0; 2926 err = native_window_set_buffers_dimensions(window, reqWidth, reqHeight); 2927 err |= native_window_set_scaling_mode(window, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW); 2928 err |= native_window_set_buffers_format(window, HAL_PIXEL_FORMAT_RGBA_8888); 2929 err |= native_window_set_usage(window, usage); 2930 2931 if (err == NO_ERROR) { 2932 ANativeWindowBuffer* buffer; 2933 /* TODO: Once we have the sync framework everywhere this can use 2934 * server-side waits on the fence that dequeueBuffer returns. 2935 */ 2936 result = native_window_dequeue_buffer_and_wait(window, &buffer); 2937 if (result == NO_ERROR) { 2938 // create an EGLImage from the buffer so we can later 2939 // turn it into a texture 2940 EGLImageKHR image = eglCreateImageKHR(mEGLDisplay, EGL_NO_CONTEXT, 2941 EGL_NATIVE_BUFFER_ANDROID, buffer, NULL); 2942 if (image != EGL_NO_IMAGE_KHR) { 2943 // this binds the given EGLImage as a framebuffer for the 2944 // duration of this scope. 2945 RenderEngine::BindImageAsFramebuffer imageBond(getRenderEngine(), image); 2946 if (imageBond.getStatus() == NO_ERROR) { 2947 // this will in fact render into our dequeued buffer 2948 // via an FBO, which means we didn't have to create 2949 // an EGLSurface and therefore we're not 2950 // dependent on the context's EGLConfig. 2951 renderScreenImplLocked(hw, reqWidth, reqHeight, 2952 minLayerZ, maxLayerZ, true, useIdentityTransform); 2953 2954 // Create a sync point and wait on it, so we know the buffer is 2955 // ready before we pass it along. We can't trivially call glFlush(), 2956 // so we use a wait flag instead. 2957 // TODO: pass a sync fd to queueBuffer() and let the consumer wait. 2958 EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, NULL); 2959 if (sync != EGL_NO_SYNC_KHR) { 2960 EGLint result = eglClientWaitSyncKHR(mEGLDisplay, sync, 2961 EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, 2000000000 /*2 sec*/); 2962 EGLint eglErr = eglGetError(); 2963 eglDestroySyncKHR(mEGLDisplay, sync); 2964 if (result == EGL_TIMEOUT_EXPIRED_KHR) { 2965 ALOGW("captureScreen: fence wait timed out"); 2966 } else { 2967 ALOGW_IF(eglErr != EGL_SUCCESS, 2968 "captureScreen: error waiting on EGL fence: %#x", eglErr); 2969 } 2970 } else { 2971 ALOGW("captureScreen: error creating EGL fence: %#x", eglGetError()); 2972 // not fatal 2973 } 2974 2975 if (DEBUG_SCREENSHOTS) { 2976 uint32_t* pixels = new uint32_t[reqWidth*reqHeight]; 2977 getRenderEngine().readPixels(0, 0, reqWidth, reqHeight, pixels); 2978 checkScreenshot(reqWidth, reqHeight, reqWidth, pixels, 2979 hw, minLayerZ, maxLayerZ); 2980 delete [] pixels; 2981 } 2982 2983 } else { 2984 ALOGE("got GL_FRAMEBUFFER_COMPLETE_OES error while taking screenshot"); 2985 result = INVALID_OPERATION; 2986 } 2987 // destroy our image 2988 eglDestroyImageKHR(mEGLDisplay, image); 2989 } else { 2990 result = BAD_VALUE; 2991 } 2992 window->queueBuffer(window, buffer, -1); 2993 } 2994 } else { 2995 result = BAD_VALUE; 2996 } 2997 native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL); 2998 } 2999 3000 return result; 3001} 3002 3003void SurfaceFlinger::checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr, 3004 const sp<const DisplayDevice>& hw, uint32_t minLayerZ, uint32_t maxLayerZ) { 3005 if (DEBUG_SCREENSHOTS) { 3006 for (size_t y=0 ; y<h ; y++) { 3007 uint32_t const * p = (uint32_t const *)vaddr + y*s; 3008 for (size_t x=0 ; x<w ; x++) { 3009 if (p[x] != 0xFF000000) return; 3010 } 3011 } 3012 ALOGE("*** we just took a black screenshot ***\n" 3013 "requested minz=%d, maxz=%d, layerStack=%d", 3014 minLayerZ, maxLayerZ, hw->getLayerStack()); 3015 const LayerVector& layers( mDrawingState.layersSortedByZ ); 3016 const size_t count = layers.size(); 3017 for (size_t i=0 ; i<count ; ++i) { 3018 const sp<Layer>& layer(layers[i]); 3019 const Layer::State& state(layer->getDrawingState()); 3020 const bool visible = (state.layerStack == hw->getLayerStack()) 3021 && (state.z >= minLayerZ && state.z <= maxLayerZ) 3022 && (layer->isVisible()); 3023 ALOGE("%c index=%zu, name=%s, layerStack=%d, z=%d, visible=%d, flags=%x, alpha=%x", 3024 visible ? '+' : '-', 3025 i, layer->getName().string(), state.layerStack, state.z, 3026 layer->isVisible(), state.flags, state.alpha); 3027 } 3028 } 3029} 3030 3031// --------------------------------------------------------------------------- 3032 3033SurfaceFlinger::LayerVector::LayerVector() { 3034} 3035 3036SurfaceFlinger::LayerVector::LayerVector(const LayerVector& rhs) 3037 : SortedVector<sp<Layer> >(rhs) { 3038} 3039 3040int SurfaceFlinger::LayerVector::do_compare(const void* lhs, 3041 const void* rhs) const 3042{ 3043 // sort layers per layer-stack, then by z-order and finally by sequence 3044 const sp<Layer>& l(*reinterpret_cast<const sp<Layer>*>(lhs)); 3045 const sp<Layer>& r(*reinterpret_cast<const sp<Layer>*>(rhs)); 3046 3047 uint32_t ls = l->getCurrentState().layerStack; 3048 uint32_t rs = r->getCurrentState().layerStack; 3049 if (ls != rs) 3050 return ls - rs; 3051 3052 uint32_t lz = l->getCurrentState().z; 3053 uint32_t rz = r->getCurrentState().z; 3054 if (lz != rz) 3055 return lz - rz; 3056 3057 return l->sequence - r->sequence; 3058} 3059 3060// --------------------------------------------------------------------------- 3061 3062SurfaceFlinger::DisplayDeviceState::DisplayDeviceState() 3063 : type(DisplayDevice::DISPLAY_ID_INVALID) { 3064} 3065 3066SurfaceFlinger::DisplayDeviceState::DisplayDeviceState(DisplayDevice::DisplayType type) 3067 : type(type), layerStack(DisplayDevice::NO_LAYER_STACK), orientation(0) { 3068 viewport.makeInvalid(); 3069 frame.makeInvalid(); 3070} 3071 3072// --------------------------------------------------------------------------- 3073 3074}; // namespace android 3075 3076 3077#if defined(__gl_h_) 3078#error "don't include gl/gl.h in this file" 3079#endif 3080 3081#if defined(__gl2_h_) 3082#error "don't include gl2/gl2.h in this file" 3083#endif 3084