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