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