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