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