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