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