SurfaceFlinger.cpp revision 8785578391eacd4192333d7b0ce3afedd7d163e6
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 if (what & eLayerStackChanged) { 1576 if (layer->setLayerStack(s.layerStack)) 1577 flags |= eTraversalNeeded; 1578 } 1579 } 1580 return flags; 1581} 1582 1583// --------------------------------------------------------------------------- 1584 1585void SurfaceFlinger::onScreenAcquired() { 1586 ALOGD("Screen about to return, flinger = %p", this); 1587 const DisplayHardware& hw(getDefaultDisplayHardware()); // XXX: this should be per DisplayHardware 1588 hw.acquireScreen(); 1589 mEventThread->onScreenAcquired(); 1590 // this is a temporary work-around, eventually this should be called 1591 // by the power-manager 1592 SurfaceFlinger::turnElectronBeamOn(mElectronBeamAnimationMode); 1593 // from this point on, SF will process updates again 1594 repaintEverything(); 1595} 1596 1597void SurfaceFlinger::onScreenReleased() { 1598 ALOGD("About to give-up screen, flinger = %p", this); 1599 const DisplayHardware& hw(getDefaultDisplayHardware()); // XXX: this should be per DisplayHardware 1600 if (hw.isScreenAcquired()) { 1601 mEventThread->onScreenReleased(); 1602 hw.releaseScreen(); 1603 // from this point on, SF will stop drawing 1604 } 1605} 1606 1607void SurfaceFlinger::unblank() { 1608 class MessageScreenAcquired : public MessageBase { 1609 SurfaceFlinger* flinger; 1610 public: 1611 MessageScreenAcquired(SurfaceFlinger* flinger) : flinger(flinger) { } 1612 virtual bool handler() { 1613 flinger->onScreenAcquired(); 1614 return true; 1615 } 1616 }; 1617 sp<MessageBase> msg = new MessageScreenAcquired(this); 1618 postMessageSync(msg); 1619} 1620 1621void SurfaceFlinger::blank() { 1622 class MessageScreenReleased : public MessageBase { 1623 SurfaceFlinger* flinger; 1624 public: 1625 MessageScreenReleased(SurfaceFlinger* flinger) : flinger(flinger) { } 1626 virtual bool handler() { 1627 flinger->onScreenReleased(); 1628 return true; 1629 } 1630 }; 1631 sp<MessageBase> msg = new MessageScreenReleased(this); 1632 postMessageSync(msg); 1633} 1634 1635// --------------------------------------------------------------------------- 1636 1637status_t SurfaceFlinger::dump(int fd, const Vector<String16>& args) 1638{ 1639 const size_t SIZE = 4096; 1640 char buffer[SIZE]; 1641 String8 result; 1642 1643 if (!PermissionCache::checkCallingPermission(sDump)) { 1644 snprintf(buffer, SIZE, "Permission Denial: " 1645 "can't dump SurfaceFlinger from pid=%d, uid=%d\n", 1646 IPCThreadState::self()->getCallingPid(), 1647 IPCThreadState::self()->getCallingUid()); 1648 result.append(buffer); 1649 } else { 1650 // Try to get the main lock, but don't insist if we can't 1651 // (this would indicate SF is stuck, but we want to be able to 1652 // print something in dumpsys). 1653 int retry = 3; 1654 while (mStateLock.tryLock()<0 && --retry>=0) { 1655 usleep(1000000); 1656 } 1657 const bool locked(retry >= 0); 1658 if (!locked) { 1659 snprintf(buffer, SIZE, 1660 "SurfaceFlinger appears to be unresponsive, " 1661 "dumping anyways (no locks held)\n"); 1662 result.append(buffer); 1663 } 1664 1665 bool dumpAll = true; 1666 size_t index = 0; 1667 size_t numArgs = args.size(); 1668 if (numArgs) { 1669 if ((index < numArgs) && 1670 (args[index] == String16("--list"))) { 1671 index++; 1672 listLayersLocked(args, index, result, buffer, SIZE); 1673 dumpAll = false; 1674 } 1675 1676 if ((index < numArgs) && 1677 (args[index] == String16("--latency"))) { 1678 index++; 1679 dumpStatsLocked(args, index, result, buffer, SIZE); 1680 dumpAll = false; 1681 } 1682 1683 if ((index < numArgs) && 1684 (args[index] == String16("--latency-clear"))) { 1685 index++; 1686 clearStatsLocked(args, index, result, buffer, SIZE); 1687 dumpAll = false; 1688 } 1689 } 1690 1691 if (dumpAll) { 1692 dumpAllLocked(result, buffer, SIZE); 1693 } 1694 1695 if (locked) { 1696 mStateLock.unlock(); 1697 } 1698 } 1699 write(fd, result.string(), result.size()); 1700 return NO_ERROR; 1701} 1702 1703void SurfaceFlinger::listLayersLocked(const Vector<String16>& args, size_t& index, 1704 String8& result, char* buffer, size_t SIZE) const 1705{ 1706 const LayerVector& currentLayers = mCurrentState.layersSortedByZ; 1707 const size_t count = currentLayers.size(); 1708 for (size_t i=0 ; i<count ; i++) { 1709 const sp<LayerBase>& layer(currentLayers[i]); 1710 snprintf(buffer, SIZE, "%s\n", layer->getName().string()); 1711 result.append(buffer); 1712 } 1713} 1714 1715void SurfaceFlinger::dumpStatsLocked(const Vector<String16>& args, size_t& index, 1716 String8& result, char* buffer, size_t SIZE) const 1717{ 1718 String8 name; 1719 if (index < args.size()) { 1720 name = String8(args[index]); 1721 index++; 1722 } 1723 1724 const LayerVector& currentLayers = mCurrentState.layersSortedByZ; 1725 const size_t count = currentLayers.size(); 1726 for (size_t i=0 ; i<count ; i++) { 1727 const sp<LayerBase>& layer(currentLayers[i]); 1728 if (name.isEmpty()) { 1729 snprintf(buffer, SIZE, "%s\n", layer->getName().string()); 1730 result.append(buffer); 1731 } 1732 if (name.isEmpty() || (name == layer->getName())) { 1733 layer->dumpStats(result, buffer, SIZE); 1734 } 1735 } 1736} 1737 1738void SurfaceFlinger::clearStatsLocked(const Vector<String16>& args, size_t& index, 1739 String8& result, char* buffer, size_t SIZE) const 1740{ 1741 String8 name; 1742 if (index < args.size()) { 1743 name = String8(args[index]); 1744 index++; 1745 } 1746 1747 const LayerVector& currentLayers = mCurrentState.layersSortedByZ; 1748 const size_t count = currentLayers.size(); 1749 for (size_t i=0 ; i<count ; i++) { 1750 const sp<LayerBase>& layer(currentLayers[i]); 1751 if (name.isEmpty() || (name == layer->getName())) { 1752 layer->clearStats(); 1753 } 1754 } 1755} 1756 1757void SurfaceFlinger::dumpAllLocked( 1758 String8& result, char* buffer, size_t SIZE) const 1759{ 1760 // figure out if we're stuck somewhere 1761 const nsecs_t now = systemTime(); 1762 const nsecs_t inSwapBuffers(mDebugInSwapBuffers); 1763 const nsecs_t inTransaction(mDebugInTransaction); 1764 nsecs_t inSwapBuffersDuration = (inSwapBuffers) ? now-inSwapBuffers : 0; 1765 nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0; 1766 1767 /* 1768 * Dump the visible layer list 1769 */ 1770 const LayerVector& currentLayers = mCurrentState.layersSortedByZ; 1771 const size_t count = currentLayers.size(); 1772 snprintf(buffer, SIZE, "Visible layers (count = %d)\n", count); 1773 result.append(buffer); 1774 for (size_t i=0 ; i<count ; i++) { 1775 const sp<LayerBase>& layer(currentLayers[i]); 1776 layer->dump(result, buffer, SIZE); 1777 } 1778 1779 /* 1780 * Dump the layers in the purgatory 1781 */ 1782 1783 const size_t purgatorySize = mLayerPurgatory.size(); 1784 snprintf(buffer, SIZE, "Purgatory state (%d entries)\n", purgatorySize); 1785 result.append(buffer); 1786 for (size_t i=0 ; i<purgatorySize ; i++) { 1787 const sp<LayerBase>& layer(mLayerPurgatory.itemAt(i)); 1788 layer->shortDump(result, buffer, SIZE); 1789 } 1790 1791 /* 1792 * Dump SurfaceFlinger global state 1793 */ 1794 1795 snprintf(buffer, SIZE, "SurfaceFlinger global state:\n"); 1796 result.append(buffer); 1797 1798 const DisplayHardware& hw(getDefaultDisplayHardware()); 1799 const GLExtensions& extensions(GLExtensions::getInstance()); 1800 snprintf(buffer, SIZE, "GLES: %s, %s, %s\n", 1801 extensions.getVendor(), 1802 extensions.getRenderer(), 1803 extensions.getVersion()); 1804 result.append(buffer); 1805 1806 snprintf(buffer, SIZE, "EGL : %s\n", 1807 eglQueryString(hw.getEGLDisplay(), 1808 EGL_VERSION_HW_ANDROID)); 1809 result.append(buffer); 1810 1811 snprintf(buffer, SIZE, "EXTS: %s\n", extensions.getExtension()); 1812 result.append(buffer); 1813 1814 mWormholeRegion.dump(result, "WormholeRegion"); 1815 snprintf(buffer, SIZE, 1816 " orientation=%d, canDraw=%d\n", 1817 mCurrentState.orientation, hw.canDraw()); 1818 result.append(buffer); 1819 snprintf(buffer, SIZE, 1820 " last eglSwapBuffers() time: %f us\n" 1821 " last transaction time : %f us\n" 1822 " transaction-flags : %08x\n" 1823 " refresh-rate : %f fps\n" 1824 " x-dpi : %f\n" 1825 " y-dpi : %f\n" 1826 " density : %f\n", 1827 mLastSwapBufferTime/1000.0, 1828 mLastTransactionTime/1000.0, 1829 mTransactionFlags, 1830 hw.getRefreshRate(), 1831 hw.getDpiX(), 1832 hw.getDpiY(), 1833 hw.getDensity()); 1834 result.append(buffer); 1835 1836 snprintf(buffer, SIZE, " eglSwapBuffers time: %f us\n", 1837 inSwapBuffersDuration/1000.0); 1838 result.append(buffer); 1839 1840 snprintf(buffer, SIZE, " transaction time: %f us\n", 1841 inTransactionDuration/1000.0); 1842 result.append(buffer); 1843 1844 /* 1845 * VSYNC state 1846 */ 1847 mEventThread->dump(result, buffer, SIZE); 1848 1849 /* 1850 * Dump HWComposer state 1851 */ 1852 HWComposer& hwc(hw.getHwComposer()); 1853 snprintf(buffer, SIZE, "h/w composer state:\n"); 1854 result.append(buffer); 1855 snprintf(buffer, SIZE, " h/w composer %s and %s\n", 1856 hwc.initCheck()==NO_ERROR ? "present" : "not present", 1857 (mDebugDisableHWC || mDebugRegion) ? "disabled" : "enabled"); 1858 result.append(buffer); 1859 hwc.dump(result, buffer, SIZE, hw.getVisibleLayersSortedByZ()); 1860 1861 /* 1862 * Dump gralloc state 1863 */ 1864 const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get()); 1865 alloc.dump(result); 1866 hw.dump(result); 1867} 1868 1869status_t SurfaceFlinger::onTransact( 1870 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 1871{ 1872 switch (code) { 1873 case CREATE_CONNECTION: 1874 case SET_TRANSACTION_STATE: 1875 case SET_ORIENTATION: 1876 case BOOT_FINISHED: 1877 case TURN_ELECTRON_BEAM_OFF: 1878 case TURN_ELECTRON_BEAM_ON: 1879 case BLANK: 1880 case UNBLANK: 1881 { 1882 // codes that require permission check 1883 IPCThreadState* ipc = IPCThreadState::self(); 1884 const int pid = ipc->getCallingPid(); 1885 const int uid = ipc->getCallingUid(); 1886 if ((uid != AID_GRAPHICS) && 1887 !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)) { 1888 ALOGE("Permission Denial: " 1889 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid); 1890 return PERMISSION_DENIED; 1891 } 1892 break; 1893 } 1894 case CAPTURE_SCREEN: 1895 { 1896 // codes that require permission check 1897 IPCThreadState* ipc = IPCThreadState::self(); 1898 const int pid = ipc->getCallingPid(); 1899 const int uid = ipc->getCallingUid(); 1900 if ((uid != AID_GRAPHICS) && 1901 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) { 1902 ALOGE("Permission Denial: " 1903 "can't read framebuffer pid=%d, uid=%d", pid, uid); 1904 return PERMISSION_DENIED; 1905 } 1906 break; 1907 } 1908 } 1909 1910 status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags); 1911 if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) { 1912 CHECK_INTERFACE(ISurfaceComposer, data, reply); 1913 if (CC_UNLIKELY(!PermissionCache::checkCallingPermission(sHardwareTest))) { 1914 IPCThreadState* ipc = IPCThreadState::self(); 1915 const int pid = ipc->getCallingPid(); 1916 const int uid = ipc->getCallingUid(); 1917 ALOGE("Permission Denial: " 1918 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid); 1919 return PERMISSION_DENIED; 1920 } 1921 int n; 1922 switch (code) { 1923 case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE 1924 case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE 1925 return NO_ERROR; 1926 case 1002: // SHOW_UPDATES 1927 n = data.readInt32(); 1928 mDebugRegion = n ? n : (mDebugRegion ? 0 : 1); 1929 invalidateHwcGeometry(); 1930 repaintEverything(); 1931 return NO_ERROR; 1932 case 1004:{ // repaint everything 1933 repaintEverything(); 1934 return NO_ERROR; 1935 } 1936 case 1005:{ // force transaction 1937 setTransactionFlags(eTransactionNeeded|eTraversalNeeded); 1938 return NO_ERROR; 1939 } 1940 case 1006:{ // send empty update 1941 signalRefresh(); 1942 return NO_ERROR; 1943 } 1944 case 1008: // toggle use of hw composer 1945 n = data.readInt32(); 1946 mDebugDisableHWC = n ? 1 : 0; 1947 invalidateHwcGeometry(); 1948 repaintEverything(); 1949 return NO_ERROR; 1950 case 1009: // toggle use of transform hint 1951 n = data.readInt32(); 1952 mDebugDisableTransformHint = n ? 1 : 0; 1953 invalidateHwcGeometry(); 1954 repaintEverything(); 1955 return NO_ERROR; 1956 case 1010: // interrogate. 1957 reply->writeInt32(0); 1958 reply->writeInt32(0); 1959 reply->writeInt32(mDebugRegion); 1960 reply->writeInt32(0); 1961 reply->writeInt32(mDebugDisableHWC); 1962 return NO_ERROR; 1963 case 1013: { 1964 Mutex::Autolock _l(mStateLock); 1965 const DisplayHardware& hw(getDefaultDisplayHardware()); 1966 reply->writeInt32(hw.getPageFlipCount()); 1967 } 1968 return NO_ERROR; 1969 } 1970 } 1971 return err; 1972} 1973 1974void SurfaceFlinger::repaintEverything() { 1975 const DisplayHardware& hw(getDefaultDisplayHardware()); // FIXME: this cannot be bound the default display 1976 const Rect bounds(hw.getBounds()); 1977 setInvalidateRegion(Region(bounds)); 1978 signalTransaction(); 1979} 1980 1981void SurfaceFlinger::setInvalidateRegion(const Region& reg) { 1982 Mutex::Autolock _l(mInvalidateLock); 1983 mInvalidateRegion = reg; 1984} 1985 1986Region SurfaceFlinger::getAndClearInvalidateRegion() { 1987 Mutex::Autolock _l(mInvalidateLock); 1988 Region reg(mInvalidateRegion); 1989 mInvalidateRegion.clear(); 1990 return reg; 1991} 1992 1993// --------------------------------------------------------------------------- 1994 1995status_t SurfaceFlinger::renderScreenToTexture(DisplayID dpy, 1996 GLuint* textureName, GLfloat* uOut, GLfloat* vOut) 1997{ 1998 Mutex::Autolock _l(mStateLock); 1999 return renderScreenToTextureLocked(dpy, textureName, uOut, vOut); 2000} 2001 2002status_t SurfaceFlinger::renderScreenToTextureLocked(DisplayID dpy, 2003 GLuint* textureName, GLfloat* uOut, GLfloat* vOut) 2004{ 2005 ATRACE_CALL(); 2006 2007 if (!GLExtensions::getInstance().haveFramebufferObject()) 2008 return INVALID_OPERATION; 2009 2010 // get screen geometry 2011 const DisplayHardware& hw(getDisplayHardware(dpy)); 2012 const uint32_t hw_w = hw.getWidth(); 2013 const uint32_t hw_h = hw.getHeight(); 2014 GLfloat u = 1; 2015 GLfloat v = 1; 2016 2017 // make sure to clear all GL error flags 2018 while ( glGetError() != GL_NO_ERROR ) ; 2019 2020 // create a FBO 2021 GLuint name, tname; 2022 glGenTextures(1, &tname); 2023 glBindTexture(GL_TEXTURE_2D, tname); 2024 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 2025 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 2026 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 2027 hw_w, hw_h, 0, GL_RGB, GL_UNSIGNED_BYTE, 0); 2028 if (glGetError() != GL_NO_ERROR) { 2029 while ( glGetError() != GL_NO_ERROR ) ; 2030 GLint tw = (2 << (31 - clz(hw_w))); 2031 GLint th = (2 << (31 - clz(hw_h))); 2032 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 2033 tw, th, 0, GL_RGB, GL_UNSIGNED_BYTE, 0); 2034 u = GLfloat(hw_w) / tw; 2035 v = GLfloat(hw_h) / th; 2036 } 2037 glGenFramebuffersOES(1, &name); 2038 glBindFramebufferOES(GL_FRAMEBUFFER_OES, name); 2039 glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES, 2040 GL_COLOR_ATTACHMENT0_OES, GL_TEXTURE_2D, tname, 0); 2041 2042 // redraw the screen entirely... 2043 glDisable(GL_TEXTURE_EXTERNAL_OES); 2044 glDisable(GL_TEXTURE_2D); 2045 glClearColor(0,0,0,1); 2046 glClear(GL_COLOR_BUFFER_BIT); 2047 glMatrixMode(GL_MODELVIEW); 2048 glLoadIdentity(); 2049 const Vector< sp<LayerBase> >& layers(hw.getVisibleLayersSortedByZ()); 2050 const size_t count = layers.size(); 2051 for (size_t i=0 ; i<count ; ++i) { 2052 const sp<LayerBase>& layer(layers[i]); 2053 layer->drawForSreenShot(hw); 2054 } 2055 2056 hw.compositionComplete(); 2057 2058 // back to main framebuffer 2059 glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0); 2060 glDeleteFramebuffersOES(1, &name); 2061 2062 *textureName = tname; 2063 *uOut = u; 2064 *vOut = v; 2065 return NO_ERROR; 2066} 2067 2068// --------------------------------------------------------------------------- 2069 2070class VSyncWaiter { 2071 DisplayEventReceiver::Event buffer[4]; 2072 sp<Looper> looper; 2073 sp<IDisplayEventConnection> events; 2074 sp<BitTube> eventTube; 2075public: 2076 VSyncWaiter(const sp<EventThread>& eventThread) { 2077 looper = new Looper(true); 2078 events = eventThread->createEventConnection(); 2079 eventTube = events->getDataChannel(); 2080 looper->addFd(eventTube->getFd(), 0, ALOOPER_EVENT_INPUT, 0, 0); 2081 events->requestNextVsync(); 2082 } 2083 2084 void wait() { 2085 ssize_t n; 2086 2087 looper->pollOnce(-1); 2088 // we don't handle any errors here, it doesn't matter 2089 // and we don't want to take the risk to get stuck. 2090 2091 // drain the events... 2092 while ((n = DisplayEventReceiver::getEvents( 2093 eventTube, buffer, 4)) > 0) ; 2094 2095 events->requestNextVsync(); 2096 } 2097}; 2098 2099status_t SurfaceFlinger::electronBeamOffAnimationImplLocked() 2100{ 2101 // get screen geometry 2102 const DisplayHardware& hw(getDefaultDisplayHardware()); 2103 const uint32_t hw_w = hw.getWidth(); 2104 const uint32_t hw_h = hw.getHeight(); 2105 const Region screenBounds(hw.getBounds()); 2106 2107 GLfloat u, v; 2108 GLuint tname; 2109 status_t result = renderScreenToTextureLocked(0, &tname, &u, &v); 2110 if (result != NO_ERROR) { 2111 return result; 2112 } 2113 2114 GLfloat vtx[8]; 2115 const GLfloat texCoords[4][2] = { {0,0}, {0,v}, {u,v}, {u,0} }; 2116 glBindTexture(GL_TEXTURE_2D, tname); 2117 glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 2118 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 2119 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 2120 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 2121 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 2122 glTexCoordPointer(2, GL_FLOAT, 0, texCoords); 2123 glEnableClientState(GL_TEXTURE_COORD_ARRAY); 2124 glVertexPointer(2, GL_FLOAT, 0, vtx); 2125 2126 /* 2127 * Texture coordinate mapping 2128 * 2129 * u 2130 * 1 +----------+---+ 2131 * | | | | image is inverted 2132 * | V | | w.r.t. the texture 2133 * 1-v +----------+ | coordinates 2134 * | | 2135 * | | 2136 * | | 2137 * 0 +--------------+ 2138 * 0 1 2139 * 2140 */ 2141 2142 class s_curve_interpolator { 2143 const float nbFrames, s, v; 2144 public: 2145 s_curve_interpolator(int nbFrames, float s) 2146 : nbFrames(1.0f / (nbFrames-1)), s(s), 2147 v(1.0f + expf(-s + 0.5f*s)) { 2148 } 2149 float operator()(int f) { 2150 const float x = f * nbFrames; 2151 return ((1.0f/(1.0f + expf(-x*s + 0.5f*s))) - 0.5f) * v + 0.5f; 2152 } 2153 }; 2154 2155 class v_stretch { 2156 const GLfloat hw_w, hw_h; 2157 public: 2158 v_stretch(uint32_t hw_w, uint32_t hw_h) 2159 : hw_w(hw_w), hw_h(hw_h) { 2160 } 2161 void operator()(GLfloat* vtx, float v) { 2162 const GLfloat w = hw_w + (hw_w * v); 2163 const GLfloat h = hw_h - (hw_h * v); 2164 const GLfloat x = (hw_w - w) * 0.5f; 2165 const GLfloat y = (hw_h - h) * 0.5f; 2166 vtx[0] = x; vtx[1] = y; 2167 vtx[2] = x; vtx[3] = y + h; 2168 vtx[4] = x + w; vtx[5] = y + h; 2169 vtx[6] = x + w; vtx[7] = y; 2170 } 2171 }; 2172 2173 class h_stretch { 2174 const GLfloat hw_w, hw_h; 2175 public: 2176 h_stretch(uint32_t hw_w, uint32_t hw_h) 2177 : hw_w(hw_w), hw_h(hw_h) { 2178 } 2179 void operator()(GLfloat* vtx, float v) { 2180 const GLfloat w = hw_w - (hw_w * v); 2181 const GLfloat h = 1.0f; 2182 const GLfloat x = (hw_w - w) * 0.5f; 2183 const GLfloat y = (hw_h - h) * 0.5f; 2184 vtx[0] = x; vtx[1] = y; 2185 vtx[2] = x; vtx[3] = y + h; 2186 vtx[4] = x + w; vtx[5] = y + h; 2187 vtx[6] = x + w; vtx[7] = y; 2188 } 2189 }; 2190 2191 VSyncWaiter vsync(mEventThread); 2192 2193 // the full animation is 24 frames 2194 char value[PROPERTY_VALUE_MAX]; 2195 property_get("debug.sf.electron_frames", value, "24"); 2196 int nbFrames = (atoi(value) + 1) >> 1; 2197 if (nbFrames <= 0) // just in case 2198 nbFrames = 24; 2199 2200 s_curve_interpolator itr(nbFrames, 7.5f); 2201 s_curve_interpolator itg(nbFrames, 8.0f); 2202 s_curve_interpolator itb(nbFrames, 8.5f); 2203 2204 v_stretch vverts(hw_w, hw_h); 2205 2206 glMatrixMode(GL_TEXTURE); 2207 glLoadIdentity(); 2208 glMatrixMode(GL_MODELVIEW); 2209 glLoadIdentity(); 2210 2211 glEnable(GL_BLEND); 2212 glBlendFunc(GL_ONE, GL_ONE); 2213 for (int i=0 ; i<nbFrames ; i++) { 2214 float x, y, w, h; 2215 const float vr = itr(i); 2216 const float vg = itg(i); 2217 const float vb = itb(i); 2218 2219 // wait for vsync 2220 vsync.wait(); 2221 2222 // clear screen 2223 glColorMask(1,1,1,1); 2224 glClear(GL_COLOR_BUFFER_BIT); 2225 glEnable(GL_TEXTURE_2D); 2226 2227 // draw the red plane 2228 vverts(vtx, vr); 2229 glColorMask(1,0,0,1); 2230 glDrawArrays(GL_TRIANGLE_FAN, 0, 4); 2231 2232 // draw the green plane 2233 vverts(vtx, vg); 2234 glColorMask(0,1,0,1); 2235 glDrawArrays(GL_TRIANGLE_FAN, 0, 4); 2236 2237 // draw the blue plane 2238 vverts(vtx, vb); 2239 glColorMask(0,0,1,1); 2240 glDrawArrays(GL_TRIANGLE_FAN, 0, 4); 2241 2242 // draw the white highlight (we use the last vertices) 2243 glDisable(GL_TEXTURE_2D); 2244 glColorMask(1,1,1,1); 2245 glColor4f(vg, vg, vg, 1); 2246 glDrawArrays(GL_TRIANGLE_FAN, 0, 4); 2247 hw.flip(screenBounds); 2248 } 2249 2250 h_stretch hverts(hw_w, hw_h); 2251 glDisable(GL_BLEND); 2252 glDisable(GL_TEXTURE_2D); 2253 glColorMask(1,1,1,1); 2254 for (int i=0 ; i<nbFrames ; i++) { 2255 const float v = itg(i); 2256 hverts(vtx, v); 2257 2258 // wait for vsync 2259 vsync.wait(); 2260 2261 glClear(GL_COLOR_BUFFER_BIT); 2262 glColor4f(1-v, 1-v, 1-v, 1); 2263 glDrawArrays(GL_TRIANGLE_FAN, 0, 4); 2264 hw.flip(screenBounds); 2265 } 2266 2267 glColorMask(1,1,1,1); 2268 glDisableClientState(GL_TEXTURE_COORD_ARRAY); 2269 glDeleteTextures(1, &tname); 2270 glDisable(GL_TEXTURE_2D); 2271 glDisable(GL_BLEND); 2272 return NO_ERROR; 2273} 2274 2275status_t SurfaceFlinger::electronBeamOnAnimationImplLocked() 2276{ 2277 status_t result = PERMISSION_DENIED; 2278 2279 if (!GLExtensions::getInstance().haveFramebufferObject()) 2280 return INVALID_OPERATION; 2281 2282 2283 // get screen geometry 2284 const DisplayHardware& hw(getDefaultDisplayHardware()); 2285 const uint32_t hw_w = hw.getWidth(); 2286 const uint32_t hw_h = hw.getHeight(); 2287 const Region screenBounds(hw.bounds()); 2288 2289 GLfloat u, v; 2290 GLuint tname; 2291 result = renderScreenToTextureLocked(0, &tname, &u, &v); 2292 if (result != NO_ERROR) { 2293 return result; 2294 } 2295 2296 GLfloat vtx[8]; 2297 const GLfloat texCoords[4][2] = { {0,v}, {0,0}, {u,0}, {u,v} }; 2298 glBindTexture(GL_TEXTURE_2D, tname); 2299 glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); 2300 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 2301 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 2302 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 2303 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 2304 glTexCoordPointer(2, GL_FLOAT, 0, texCoords); 2305 glEnableClientState(GL_TEXTURE_COORD_ARRAY); 2306 glVertexPointer(2, GL_FLOAT, 0, vtx); 2307 2308 class s_curve_interpolator { 2309 const float nbFrames, s, v; 2310 public: 2311 s_curve_interpolator(int nbFrames, float s) 2312 : nbFrames(1.0f / (nbFrames-1)), s(s), 2313 v(1.0f + expf(-s + 0.5f*s)) { 2314 } 2315 float operator()(int f) { 2316 const float x = f * nbFrames; 2317 return ((1.0f/(1.0f + expf(-x*s + 0.5f*s))) - 0.5f) * v + 0.5f; 2318 } 2319 }; 2320 2321 class v_stretch { 2322 const GLfloat hw_w, hw_h; 2323 public: 2324 v_stretch(uint32_t hw_w, uint32_t hw_h) 2325 : hw_w(hw_w), hw_h(hw_h) { 2326 } 2327 void operator()(GLfloat* vtx, float v) { 2328 const GLfloat w = hw_w + (hw_w * v); 2329 const GLfloat h = hw_h - (hw_h * v); 2330 const GLfloat x = (hw_w - w) * 0.5f; 2331 const GLfloat y = (hw_h - h) * 0.5f; 2332 vtx[0] = x; vtx[1] = y; 2333 vtx[2] = x; vtx[3] = y + h; 2334 vtx[4] = x + w; vtx[5] = y + h; 2335 vtx[6] = x + w; vtx[7] = y; 2336 } 2337 }; 2338 2339 class h_stretch { 2340 const GLfloat hw_w, hw_h; 2341 public: 2342 h_stretch(uint32_t hw_w, uint32_t hw_h) 2343 : hw_w(hw_w), hw_h(hw_h) { 2344 } 2345 void operator()(GLfloat* vtx, float v) { 2346 const GLfloat w = hw_w - (hw_w * v); 2347 const GLfloat h = 1.0f; 2348 const GLfloat x = (hw_w - w) * 0.5f; 2349 const GLfloat y = (hw_h - h) * 0.5f; 2350 vtx[0] = x; vtx[1] = y; 2351 vtx[2] = x; vtx[3] = y + h; 2352 vtx[4] = x + w; vtx[5] = y + h; 2353 vtx[6] = x + w; vtx[7] = y; 2354 } 2355 }; 2356 2357 VSyncWaiter vsync(mEventThread); 2358 2359 // the full animation is 12 frames 2360 int nbFrames = 8; 2361 s_curve_interpolator itr(nbFrames, 7.5f); 2362 s_curve_interpolator itg(nbFrames, 8.0f); 2363 s_curve_interpolator itb(nbFrames, 8.5f); 2364 2365 h_stretch hverts(hw_w, hw_h); 2366 glDisable(GL_BLEND); 2367 glDisable(GL_TEXTURE_2D); 2368 glColorMask(1,1,1,1); 2369 for (int i=nbFrames-1 ; i>=0 ; i--) { 2370 const float v = itg(i); 2371 hverts(vtx, v); 2372 2373 // wait for vsync 2374 vsync.wait(); 2375 2376 glClear(GL_COLOR_BUFFER_BIT); 2377 glColor4f(1-v, 1-v, 1-v, 1); 2378 glDrawArrays(GL_TRIANGLE_FAN, 0, 4); 2379 hw.flip(screenBounds); 2380 } 2381 2382 nbFrames = 4; 2383 v_stretch vverts(hw_w, hw_h); 2384 glEnable(GL_BLEND); 2385 glBlendFunc(GL_ONE, GL_ONE); 2386 for (int i=nbFrames-1 ; i>=0 ; i--) { 2387 float x, y, w, h; 2388 const float vr = itr(i); 2389 const float vg = itg(i); 2390 const float vb = itb(i); 2391 2392 // wait for vsync 2393 vsync.wait(); 2394 2395 // clear screen 2396 glColorMask(1,1,1,1); 2397 glClear(GL_COLOR_BUFFER_BIT); 2398 glEnable(GL_TEXTURE_2D); 2399 2400 // draw the red plane 2401 vverts(vtx, vr); 2402 glColorMask(1,0,0,1); 2403 glDrawArrays(GL_TRIANGLE_FAN, 0, 4); 2404 2405 // draw the green plane 2406 vverts(vtx, vg); 2407 glColorMask(0,1,0,1); 2408 glDrawArrays(GL_TRIANGLE_FAN, 0, 4); 2409 2410 // draw the blue plane 2411 vverts(vtx, vb); 2412 glColorMask(0,0,1,1); 2413 glDrawArrays(GL_TRIANGLE_FAN, 0, 4); 2414 2415 hw.flip(screenBounds); 2416 } 2417 2418 glColorMask(1,1,1,1); 2419 glDisableClientState(GL_TEXTURE_COORD_ARRAY); 2420 glDeleteTextures(1, &tname); 2421 glDisable(GL_TEXTURE_2D); 2422 glDisable(GL_BLEND); 2423 2424 return NO_ERROR; 2425} 2426 2427// --------------------------------------------------------------------------- 2428 2429status_t SurfaceFlinger::turnElectronBeamOffImplLocked(int32_t mode) 2430{ 2431 ATRACE_CALL(); 2432 2433 DisplayHardware& hw(const_cast<DisplayHardware&>(getDefaultDisplayHardware())); 2434 if (!hw.canDraw()) { 2435 // we're already off 2436 return NO_ERROR; 2437 } 2438 2439 // turn off hwc while we're doing the animation 2440 hw.getHwComposer().disable(); 2441 // and make sure to turn it back on (if needed) next time we compose 2442 invalidateHwcGeometry(); 2443 2444 if (mode & ISurfaceComposer::eElectronBeamAnimationOff) { 2445 electronBeamOffAnimationImplLocked(); 2446 } 2447 2448 // always clear the whole screen at the end of the animation 2449 glClearColor(0,0,0,1); 2450 glClear(GL_COLOR_BUFFER_BIT); 2451 hw.flip( Region(hw.bounds()) ); 2452 2453 return NO_ERROR; 2454} 2455 2456status_t SurfaceFlinger::turnElectronBeamOff(int32_t mode) 2457{ 2458 class MessageTurnElectronBeamOff : public MessageBase { 2459 SurfaceFlinger* flinger; 2460 int32_t mode; 2461 status_t result; 2462 public: 2463 MessageTurnElectronBeamOff(SurfaceFlinger* flinger, int32_t mode) 2464 : flinger(flinger), mode(mode), result(PERMISSION_DENIED) { 2465 } 2466 status_t getResult() const { 2467 return result; 2468 } 2469 virtual bool handler() { 2470 Mutex::Autolock _l(flinger->mStateLock); 2471 result = flinger->turnElectronBeamOffImplLocked(mode); 2472 return true; 2473 } 2474 }; 2475 2476 sp<MessageBase> msg = new MessageTurnElectronBeamOff(this, mode); 2477 status_t res = postMessageSync(msg); 2478 if (res == NO_ERROR) { 2479 res = static_cast<MessageTurnElectronBeamOff*>( msg.get() )->getResult(); 2480 2481 // work-around: when the power-manager calls us we activate the 2482 // animation. eventually, the "on" animation will be called 2483 // by the power-manager itself 2484 mElectronBeamAnimationMode = mode; 2485 } 2486 return res; 2487} 2488 2489// --------------------------------------------------------------------------- 2490 2491status_t SurfaceFlinger::turnElectronBeamOnImplLocked(int32_t mode) 2492{ 2493 DisplayHardware& hw(const_cast<DisplayHardware&>(getDefaultDisplayHardware())); 2494 if (hw.canDraw()) { 2495 // we're already on 2496 return NO_ERROR; 2497 } 2498 if (mode & ISurfaceComposer::eElectronBeamAnimationOn) { 2499 electronBeamOnAnimationImplLocked(); 2500 } 2501 2502 // make sure to redraw the whole screen when the animation is done 2503 mDirtyRegion.set(hw.bounds()); 2504 signalTransaction(); 2505 2506 return NO_ERROR; 2507} 2508 2509status_t SurfaceFlinger::turnElectronBeamOn(int32_t mode) 2510{ 2511 class MessageTurnElectronBeamOn : public MessageBase { 2512 SurfaceFlinger* flinger; 2513 int32_t mode; 2514 status_t result; 2515 public: 2516 MessageTurnElectronBeamOn(SurfaceFlinger* flinger, int32_t mode) 2517 : flinger(flinger), mode(mode), result(PERMISSION_DENIED) { 2518 } 2519 status_t getResult() const { 2520 return result; 2521 } 2522 virtual bool handler() { 2523 Mutex::Autolock _l(flinger->mStateLock); 2524 result = flinger->turnElectronBeamOnImplLocked(mode); 2525 return true; 2526 } 2527 }; 2528 2529 postMessageAsync( new MessageTurnElectronBeamOn(this, mode) ); 2530 return NO_ERROR; 2531} 2532 2533// --------------------------------------------------------------------------- 2534 2535status_t SurfaceFlinger::captureScreenImplLocked(DisplayID dpy, 2536 sp<IMemoryHeap>* heap, 2537 uint32_t* w, uint32_t* h, PixelFormat* f, 2538 uint32_t sw, uint32_t sh, 2539 uint32_t minLayerZ, uint32_t maxLayerZ) 2540{ 2541 ATRACE_CALL(); 2542 2543 status_t result = PERMISSION_DENIED; 2544 2545 // only one display supported for now 2546 if (CC_UNLIKELY(uint32_t(dpy) >= DISPLAY_COUNT)) { 2547 return BAD_VALUE; 2548 } 2549 2550 if (!GLExtensions::getInstance().haveFramebufferObject()) { 2551 return INVALID_OPERATION; 2552 } 2553 2554 // get screen geometry 2555 const DisplayHardware& hw(getDisplayHardware(dpy)); 2556 const uint32_t hw_w = hw.getWidth(); 2557 const uint32_t hw_h = hw.getHeight(); 2558 2559 // if we have secure windows on this display, never allow the screen capture 2560 if (hw.getSecureLayerVisible()) { 2561 return PERMISSION_DENIED; 2562 } 2563 2564 if ((sw > hw_w) || (sh > hw_h)) { 2565 return BAD_VALUE; 2566 } 2567 2568 sw = (!sw) ? hw_w : sw; 2569 sh = (!sh) ? hw_h : sh; 2570 const size_t size = sw * sh * 4; 2571 2572 //ALOGD("screenshot: sw=%d, sh=%d, minZ=%d, maxZ=%d", 2573 // sw, sh, minLayerZ, maxLayerZ); 2574 2575 // make sure to clear all GL error flags 2576 while ( glGetError() != GL_NO_ERROR ) ; 2577 2578 // create a FBO 2579 GLuint name, tname; 2580 glGenRenderbuffersOES(1, &tname); 2581 glBindRenderbufferOES(GL_RENDERBUFFER_OES, tname); 2582 glRenderbufferStorageOES(GL_RENDERBUFFER_OES, GL_RGBA8_OES, sw, sh); 2583 2584 glGenFramebuffersOES(1, &name); 2585 glBindFramebufferOES(GL_FRAMEBUFFER_OES, name); 2586 glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, 2587 GL_COLOR_ATTACHMENT0_OES, GL_RENDERBUFFER_OES, tname); 2588 2589 GLenum status = glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES); 2590 2591 if (status == GL_FRAMEBUFFER_COMPLETE_OES) { 2592 2593 // invert everything, b/c glReadPixel() below will invert the FB 2594 glViewport(0, 0, sw, sh); 2595 glMatrixMode(GL_PROJECTION); 2596 glPushMatrix(); 2597 glLoadIdentity(); 2598 glOrthof(0, hw_w, hw_h, 0, 0, 1); 2599 glMatrixMode(GL_MODELVIEW); 2600 2601 // redraw the screen entirely... 2602 glClearColor(0,0,0,1); 2603 glClear(GL_COLOR_BUFFER_BIT); 2604 2605 const LayerVector& layers(mDrawingState.layersSortedByZ); 2606 const size_t count = layers.size(); 2607 for (size_t i=0 ; i<count ; ++i) { 2608 const sp<LayerBase>& layer(layers[i]); 2609 const uint32_t flags = layer->drawingState().flags; 2610 if (!(flags & ISurfaceComposer::eLayerHidden)) { 2611 const uint32_t z = layer->drawingState().z; 2612 if (z >= minLayerZ && z <= maxLayerZ) { 2613 layer->drawForSreenShot(hw); 2614 } 2615 } 2616 } 2617 2618 // check for errors and return screen capture 2619 if (glGetError() != GL_NO_ERROR) { 2620 // error while rendering 2621 result = INVALID_OPERATION; 2622 } else { 2623 // allocate shared memory large enough to hold the 2624 // screen capture 2625 sp<MemoryHeapBase> base( 2626 new MemoryHeapBase(size, 0, "screen-capture") ); 2627 void* const ptr = base->getBase(); 2628 if (ptr) { 2629 // capture the screen with glReadPixels() 2630 ScopedTrace _t(ATRACE_TAG, "glReadPixels"); 2631 glReadPixels(0, 0, sw, sh, GL_RGBA, GL_UNSIGNED_BYTE, ptr); 2632 if (glGetError() == GL_NO_ERROR) { 2633 *heap = base; 2634 *w = sw; 2635 *h = sh; 2636 *f = PIXEL_FORMAT_RGBA_8888; 2637 result = NO_ERROR; 2638 } 2639 } else { 2640 result = NO_MEMORY; 2641 } 2642 } 2643 glViewport(0, 0, hw_w, hw_h); 2644 glMatrixMode(GL_PROJECTION); 2645 glPopMatrix(); 2646 glMatrixMode(GL_MODELVIEW); 2647 } else { 2648 result = BAD_VALUE; 2649 } 2650 2651 // release FBO resources 2652 glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0); 2653 glDeleteRenderbuffersOES(1, &tname); 2654 glDeleteFramebuffersOES(1, &name); 2655 2656 hw.compositionComplete(); 2657 2658 // ALOGD("screenshot: result = %s", result<0 ? strerror(result) : "OK"); 2659 2660 return result; 2661} 2662 2663 2664status_t SurfaceFlinger::captureScreen(DisplayID dpy, 2665 sp<IMemoryHeap>* heap, 2666 uint32_t* width, uint32_t* height, PixelFormat* format, 2667 uint32_t sw, uint32_t sh, 2668 uint32_t minLayerZ, uint32_t maxLayerZ) 2669{ 2670 // only one display supported for now 2671 if (CC_UNLIKELY(uint32_t(dpy) >= DISPLAY_COUNT)) 2672 return BAD_VALUE; 2673 2674 if (!GLExtensions::getInstance().haveFramebufferObject()) 2675 return INVALID_OPERATION; 2676 2677 class MessageCaptureScreen : public MessageBase { 2678 SurfaceFlinger* flinger; 2679 DisplayID dpy; 2680 sp<IMemoryHeap>* heap; 2681 uint32_t* w; 2682 uint32_t* h; 2683 PixelFormat* f; 2684 uint32_t sw; 2685 uint32_t sh; 2686 uint32_t minLayerZ; 2687 uint32_t maxLayerZ; 2688 status_t result; 2689 public: 2690 MessageCaptureScreen(SurfaceFlinger* flinger, DisplayID dpy, 2691 sp<IMemoryHeap>* heap, uint32_t* w, uint32_t* h, PixelFormat* f, 2692 uint32_t sw, uint32_t sh, 2693 uint32_t minLayerZ, uint32_t maxLayerZ) 2694 : flinger(flinger), dpy(dpy), 2695 heap(heap), w(w), h(h), f(f), sw(sw), sh(sh), 2696 minLayerZ(minLayerZ), maxLayerZ(maxLayerZ), 2697 result(PERMISSION_DENIED) 2698 { 2699 } 2700 status_t getResult() const { 2701 return result; 2702 } 2703 virtual bool handler() { 2704 Mutex::Autolock _l(flinger->mStateLock); 2705 result = flinger->captureScreenImplLocked(dpy, 2706 heap, w, h, f, sw, sh, minLayerZ, maxLayerZ); 2707 return true; 2708 } 2709 }; 2710 2711 sp<MessageBase> msg = new MessageCaptureScreen(this, 2712 dpy, heap, width, height, format, sw, sh, minLayerZ, maxLayerZ); 2713 status_t res = postMessageSync(msg); 2714 if (res == NO_ERROR) { 2715 res = static_cast<MessageCaptureScreen*>( msg.get() )->getResult(); 2716 } 2717 return res; 2718} 2719 2720// --------------------------------------------------------------------------- 2721 2722SurfaceFlinger::LayerVector::LayerVector() { 2723} 2724 2725SurfaceFlinger::LayerVector::LayerVector(const LayerVector& rhs) 2726 : SortedVector<sp<LayerBase> >(rhs) { 2727} 2728 2729int SurfaceFlinger::LayerVector::do_compare(const void* lhs, 2730 const void* rhs) const 2731{ 2732 const sp<LayerBase>& l(*reinterpret_cast<const sp<LayerBase>*>(lhs)); 2733 const sp<LayerBase>& r(*reinterpret_cast<const sp<LayerBase>*>(rhs)); 2734 // sort layers by Z order 2735 uint32_t lz = l->currentState().z; 2736 uint32_t rz = r->currentState().z; 2737 // then by sequence, so we get a stable ordering 2738 return (lz != rz) ? (lz - rz) : (l->sequence - r->sequence); 2739} 2740 2741// --------------------------------------------------------------------------- 2742 2743SurfaceFlinger::State::State() 2744 : orientation(ISurfaceComposer::eOrientationDefault), 2745 orientationFlags(0) { 2746} 2747 2748// --------------------------------------------------------------------------- 2749 2750GraphicBufferAlloc::GraphicBufferAlloc() {} 2751 2752GraphicBufferAlloc::~GraphicBufferAlloc() {} 2753 2754sp<GraphicBuffer> GraphicBufferAlloc::createGraphicBuffer(uint32_t w, uint32_t h, 2755 PixelFormat format, uint32_t usage, status_t* error) { 2756 sp<GraphicBuffer> graphicBuffer(new GraphicBuffer(w, h, format, usage)); 2757 status_t err = graphicBuffer->initCheck(); 2758 *error = err; 2759 if (err != 0 || graphicBuffer->handle == 0) { 2760 if (err == NO_MEMORY) { 2761 GraphicBuffer::dumpAllocationsToSystemLog(); 2762 } 2763 ALOGE("GraphicBufferAlloc::createGraphicBuffer(w=%d, h=%d) " 2764 "failed (%s), handle=%p", 2765 w, h, strerror(-err), graphicBuffer->handle); 2766 return 0; 2767 } 2768 return graphicBuffer; 2769} 2770 2771// --------------------------------------------------------------------------- 2772 2773}; // namespace android 2774