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 36 #include <utils/String8.h> 37 #include <utils/String16.h> 38 #include <utils/StopWatch.h> 39 40 #include <ui/GraphicBufferAllocator.h> 41 #include <ui/PixelFormat.h> 42 43 #include <pixelflinger/pixelflinger.h> 44 #include <GLES/gl.h> 45 46 #include "clz.h" 47 #include "Layer.h" 48 #include "LayerBlur.h" 49 #include "LayerBuffer.h" 50 #include "LayerDim.h" 51 #include "SurfaceFlinger.h" 52 53 #include "DisplayHardware/DisplayHardware.h" 54 55 /* ideally AID_GRAPHICS would be in a semi-public header 56 * or there would be a way to map a user/group name to its id 57 */ 58 #ifndef AID_GRAPHICS 59 #define AID_GRAPHICS 1003 60 #endif 61 62 #define DISPLAY_COUNT 1 63 64 namespace android { 65 66 // --------------------------------------------------------------------------- 67 68 void SurfaceFlinger::instantiate() { 69 defaultServiceManager()->addService( 70 String16("SurfaceFlinger"), new SurfaceFlinger()); 71 } 72 73 void SurfaceFlinger::shutdown() { 74 // we should unregister here, but not really because 75 // when (if) the service manager goes away, all the services 76 // it has a reference to will leave too. 77 } 78 79 // --------------------------------------------------------------------------- 80 81 SurfaceFlinger::LayerVector::LayerVector(const SurfaceFlinger::LayerVector& rhs) 82 : lookup(rhs.lookup), layers(rhs.layers) 83 { 84 } 85 86 ssize_t SurfaceFlinger::LayerVector::indexOf( 87 const sp<LayerBase>& key, size_t guess) const 88 { 89 if (guess<size() && lookup.keyAt(guess) == key) 90 return guess; 91 const ssize_t i = lookup.indexOfKey(key); 92 if (i>=0) { 93 const size_t idx = lookup.valueAt(i); 94 LOGE_IF(layers[idx]!=key, 95 "LayerVector[%p]: layers[%d]=%p, key=%p", 96 this, int(idx), layers[idx].get(), key.get()); 97 return idx; 98 } 99 return i; 100 } 101 102 ssize_t SurfaceFlinger::LayerVector::add( 103 const sp<LayerBase>& layer, 104 Vector< sp<LayerBase> >::compar_t cmp) 105 { 106 size_t count = layers.size(); 107 ssize_t l = 0; 108 ssize_t h = count-1; 109 ssize_t mid; 110 sp<LayerBase> const* a = layers.array(); 111 while (l <= h) { 112 mid = l + (h - l)/2; 113 const int c = cmp(a+mid, &layer); 114 if (c == 0) { l = mid; break; } 115 else if (c<0) { l = mid+1; } 116 else { h = mid-1; } 117 } 118 size_t order = l; 119 while (order<count && !cmp(&layer, a+order)) { 120 order++; 121 } 122 count = lookup.size(); 123 for (size_t i=0 ; i<count ; i++) { 124 if (lookup.valueAt(i) >= order) { 125 lookup.editValueAt(i)++; 126 } 127 } 128 layers.insertAt(layer, order); 129 lookup.add(layer, order); 130 return order; 131 } 132 133 ssize_t SurfaceFlinger::LayerVector::remove(const sp<LayerBase>& layer) 134 { 135 const ssize_t keyIndex = lookup.indexOfKey(layer); 136 if (keyIndex >= 0) { 137 const size_t index = lookup.valueAt(keyIndex); 138 LOGE_IF(layers[index]!=layer, 139 "LayerVector[%p]: layers[%u]=%p, layer=%p", 140 this, int(index), layers[index].get(), layer.get()); 141 layers.removeItemsAt(index); 142 lookup.removeItemsAt(keyIndex); 143 const size_t count = lookup.size(); 144 for (size_t i=0 ; i<count ; i++) { 145 if (lookup.valueAt(i) >= size_t(index)) { 146 lookup.editValueAt(i)--; 147 } 148 } 149 return index; 150 } 151 return NAME_NOT_FOUND; 152 } 153 154 ssize_t SurfaceFlinger::LayerVector::reorder( 155 const sp<LayerBase>& layer, 156 Vector< sp<LayerBase> >::compar_t cmp) 157 { 158 // XXX: it's a little lame. but oh well... 159 ssize_t err = remove(layer); 160 if (err >=0) 161 err = add(layer, cmp); 162 return err; 163 } 164 165 // --------------------------------------------------------------------------- 166 #if 0 167 #pragma mark - 168 #endif 169 170 SurfaceFlinger::SurfaceFlinger() 171 : BnSurfaceComposer(), Thread(false), 172 mTransactionFlags(0), 173 mTransactionCount(0), 174 mResizeTransationPending(false), 175 mLayersRemoved(false), 176 mBootTime(systemTime()), 177 mHardwareTest("android.permission.HARDWARE_TEST"), 178 mAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER"), 179 mDump("android.permission.DUMP"), 180 mVisibleRegionsDirty(false), 181 mDeferReleaseConsole(false), 182 mFreezeDisplay(false), 183 mFreezeCount(0), 184 mFreezeDisplayTime(0), 185 mDebugRegion(0), 186 mDebugBackground(0), 187 mDebugInSwapBuffers(0), 188 mLastSwapBufferTime(0), 189 mDebugInTransaction(0), 190 mLastTransactionTime(0), 191 mBootFinished(false), 192 mConsoleSignals(0), 193 mSecureFrameBuffer(0) 194 { 195 init(); 196 } 197 198 void SurfaceFlinger::init() 199 { 200 LOGI("SurfaceFlinger is starting"); 201 202 // debugging stuff... 203 char value[PROPERTY_VALUE_MAX]; 204 property_get("debug.sf.showupdates", value, "0"); 205 mDebugRegion = atoi(value); 206 property_get("debug.sf.showbackground", value, "0"); 207 mDebugBackground = atoi(value); 208 209 LOGI_IF(mDebugRegion, "showupdates enabled"); 210 LOGI_IF(mDebugBackground, "showbackground enabled"); 211 } 212 213 SurfaceFlinger::~SurfaceFlinger() 214 { 215 glDeleteTextures(1, &mWormholeTexName); 216 } 217 218 overlay_control_device_t* SurfaceFlinger::getOverlayEngine() const 219 { 220 return graphicPlane(0).displayHardware().getOverlayEngine(); 221 } 222 223 sp<IMemoryHeap> SurfaceFlinger::getCblk() const 224 { 225 return mServerHeap; 226 } 227 228 sp<ISurfaceFlingerClient> SurfaceFlinger::createConnection() 229 { 230 Mutex::Autolock _l(mStateLock); 231 uint32_t token = mTokens.acquire(); 232 233 sp<Client> client = new Client(token, this); 234 if (client->ctrlblk == 0) { 235 mTokens.release(token); 236 return 0; 237 } 238 status_t err = mClientsMap.add(token, client); 239 if (err < 0) { 240 mTokens.release(token); 241 return 0; 242 } 243 sp<BClient> bclient = 244 new BClient(this, token, client->getControlBlockMemory()); 245 return bclient; 246 } 247 248 void SurfaceFlinger::destroyConnection(ClientID cid) 249 { 250 Mutex::Autolock _l(mStateLock); 251 sp<Client> client = mClientsMap.valueFor(cid); 252 if (client != 0) { 253 // free all the layers this client owns 254 Vector< wp<LayerBaseClient> > layers(client->getLayers()); 255 const size_t count = layers.size(); 256 for (size_t i=0 ; i<count ; i++) { 257 sp<LayerBaseClient> layer(layers[i].promote()); 258 if (layer != 0) { 259 purgatorizeLayer_l(layer); 260 } 261 } 262 263 // the resources associated with this client will be freed 264 // during the next transaction, after these surfaces have been 265 // properly removed from the screen 266 267 // remove this client from our ClientID->Client mapping. 268 mClientsMap.removeItem(cid); 269 270 // and add it to the list of disconnected clients 271 mDisconnectedClients.add(client); 272 273 // request a transaction 274 setTransactionFlags(eTransactionNeeded); 275 } 276 } 277 278 const GraphicPlane& SurfaceFlinger::graphicPlane(int dpy) const 279 { 280 LOGE_IF(uint32_t(dpy) >= DISPLAY_COUNT, "Invalid DisplayID %d", dpy); 281 const GraphicPlane& plane(mGraphicPlanes[dpy]); 282 return plane; 283 } 284 285 GraphicPlane& SurfaceFlinger::graphicPlane(int dpy) 286 { 287 return const_cast<GraphicPlane&>( 288 const_cast<SurfaceFlinger const *>(this)->graphicPlane(dpy)); 289 } 290 291 void SurfaceFlinger::bootFinished() 292 { 293 const nsecs_t now = systemTime(); 294 const nsecs_t duration = now - mBootTime; 295 LOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) ); 296 mBootFinished = true; 297 property_set("ctl.stop", "bootanim"); 298 } 299 300 void SurfaceFlinger::onFirstRef() 301 { 302 run("SurfaceFlinger", PRIORITY_URGENT_DISPLAY); 303 304 // Wait for the main thread to be done with its initialization 305 mReadyToRunBarrier.wait(); 306 } 307 308 static inline uint16_t pack565(int r, int g, int b) { 309 return (r<<11)|(g<<5)|b; 310 } 311 312 status_t SurfaceFlinger::readyToRun() 313 { 314 LOGI( "SurfaceFlinger's main thread ready to run. " 315 "Initializing graphics H/W..."); 316 317 // we only support one display currently 318 int dpy = 0; 319 320 { 321 // initialize the main display 322 GraphicPlane& plane(graphicPlane(dpy)); 323 DisplayHardware* const hw = new DisplayHardware(this, dpy); 324 plane.setDisplayHardware(hw); 325 } 326 327 // create the shared control-block 328 mServerHeap = new MemoryHeapBase(4096, 329 MemoryHeapBase::READ_ONLY, "SurfaceFlinger read-only heap"); 330 LOGE_IF(mServerHeap==0, "can't create shared memory dealer"); 331 332 mServerCblk = static_cast<surface_flinger_cblk_t*>(mServerHeap->getBase()); 333 LOGE_IF(mServerCblk==0, "can't get to shared control block's address"); 334 335 new(mServerCblk) surface_flinger_cblk_t; 336 337 // initialize primary screen 338 // (other display should be initialized in the same manner, but 339 // asynchronously, as they could come and go. None of this is supported 340 // yet). 341 const GraphicPlane& plane(graphicPlane(dpy)); 342 const DisplayHardware& hw = plane.displayHardware(); 343 const uint32_t w = hw.getWidth(); 344 const uint32_t h = hw.getHeight(); 345 const uint32_t f = hw.getFormat(); 346 hw.makeCurrent(); 347 348 // initialize the shared control block 349 mServerCblk->connected |= 1<<dpy; 350 display_cblk_t* dcblk = mServerCblk->displays + dpy; 351 memset(dcblk, 0, sizeof(display_cblk_t)); 352 dcblk->w = plane.getWidth(); 353 dcblk->h = plane.getHeight(); 354 dcblk->format = f; 355 dcblk->orientation = ISurfaceComposer::eOrientationDefault; 356 dcblk->xdpi = hw.getDpiX(); 357 dcblk->ydpi = hw.getDpiY(); 358 dcblk->fps = hw.getRefreshRate(); 359 dcblk->density = hw.getDensity(); 360 asm volatile ("":::"memory"); 361 362 // Initialize OpenGL|ES 363 glActiveTexture(GL_TEXTURE0); 364 glBindTexture(GL_TEXTURE_2D, 0); 365 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 366 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 367 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 368 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 369 glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 370 glPixelStorei(GL_UNPACK_ALIGNMENT, 4); 371 glPixelStorei(GL_PACK_ALIGNMENT, 4); 372 glEnableClientState(GL_VERTEX_ARRAY); 373 glEnable(GL_SCISSOR_TEST); 374 glShadeModel(GL_FLAT); 375 glDisable(GL_DITHER); 376 glDisable(GL_CULL_FACE); 377 378 const uint16_t g0 = pack565(0x0F,0x1F,0x0F); 379 const uint16_t g1 = pack565(0x17,0x2f,0x17); 380 const uint16_t textureData[4] = { g0, g1, g1, g0 }; 381 glGenTextures(1, &mWormholeTexName); 382 glBindTexture(GL_TEXTURE_2D, mWormholeTexName); 383 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 384 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 385 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); 386 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); 387 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 2, 2, 0, 388 GL_RGB, GL_UNSIGNED_SHORT_5_6_5, textureData); 389 390 glViewport(0, 0, w, h); 391 glMatrixMode(GL_PROJECTION); 392 glLoadIdentity(); 393 glOrthof(0, w, h, 0, 0, 1); 394 395 LayerDim::initDimmer(this, w, h); 396 397 mReadyToRunBarrier.open(); 398 399 /* 400 * We're now ready to accept clients... 401 */ 402 403 // start boot animation 404 property_set("ctl.start", "bootanim"); 405 406 return NO_ERROR; 407 } 408 409 // ---------------------------------------------------------------------------- 410 #if 0 411 #pragma mark - 412 #pragma mark Events Handler 413 #endif 414 415 void SurfaceFlinger::waitForEvent() 416 { 417 while (true) { 418 nsecs_t timeout = -1; 419 const nsecs_t freezeDisplayTimeout = ms2ns(5000); 420 if (UNLIKELY(isFrozen())) { 421 // wait 5 seconds 422 const nsecs_t now = systemTime(); 423 if (mFreezeDisplayTime == 0) { 424 mFreezeDisplayTime = now; 425 } 426 nsecs_t waitTime = freezeDisplayTimeout - (now - mFreezeDisplayTime); 427 timeout = waitTime>0 ? waitTime : 0; 428 } 429 430 MessageList::value_type msg = mEventQueue.waitMessage(timeout); 431 432 // see if we timed out 433 if (isFrozen()) { 434 const nsecs_t now = systemTime(); 435 nsecs_t frozenTime = (now - mFreezeDisplayTime); 436 if (frozenTime >= freezeDisplayTimeout) { 437 // we timed out and are still frozen 438 LOGW("timeout expired mFreezeDisplay=%d, mFreezeCount=%d", 439 mFreezeDisplay, mFreezeCount); 440 mFreezeDisplayTime = 0; 441 mFreezeCount = 0; 442 mFreezeDisplay = false; 443 } 444 } 445 446 if (msg != 0) { 447 switch (msg->what) { 448 case MessageQueue::INVALIDATE: 449 // invalidate message, just return to the main loop 450 return; 451 } 452 } 453 } 454 } 455 456 void SurfaceFlinger::signalEvent() { 457 mEventQueue.invalidate(); 458 } 459 460 void SurfaceFlinger::signal() const { 461 // this is the IPC call 462 const_cast<SurfaceFlinger*>(this)->signalEvent(); 463 } 464 465 void SurfaceFlinger::signalDelayedEvent(nsecs_t delay) 466 { 467 mEventQueue.postMessage( new MessageBase(MessageQueue::INVALIDATE), delay); 468 } 469 470 // ---------------------------------------------------------------------------- 471 #if 0 472 #pragma mark - 473 #pragma mark Main loop 474 #endif 475 476 bool SurfaceFlinger::threadLoop() 477 { 478 waitForEvent(); 479 480 // check for transactions 481 if (UNLIKELY(mConsoleSignals)) { 482 handleConsoleEvents(); 483 } 484 485 if (LIKELY(mTransactionCount == 0)) { 486 // if we're in a global transaction, don't do anything. 487 const uint32_t mask = eTransactionNeeded | eTraversalNeeded; 488 uint32_t transactionFlags = getTransactionFlags(mask); 489 if (LIKELY(transactionFlags)) { 490 handleTransaction(transactionFlags); 491 } 492 } 493 494 // post surfaces (if needed) 495 handlePageFlip(); 496 497 const DisplayHardware& hw(graphicPlane(0).displayHardware()); 498 if (LIKELY(hw.canDraw() && !isFrozen())) { 499 // repaint the framebuffer (if needed) 500 handleRepaint(); 501 502 // inform the h/w that we're done compositing 503 hw.compositionComplete(); 504 505 // release the clients before we flip ('cause flip might block) 506 unlockClients(); 507 508 postFramebuffer(); 509 } else { 510 // pretend we did the post 511 unlockClients(); 512 usleep(16667); // 60 fps period 513 } 514 return true; 515 } 516 517 void SurfaceFlinger::postFramebuffer() 518 { 519 if (!mInvalidRegion.isEmpty()) { 520 const DisplayHardware& hw(graphicPlane(0).displayHardware()); 521 const nsecs_t now = systemTime(); 522 mDebugInSwapBuffers = now; 523 hw.flip(mInvalidRegion); 524 mLastSwapBufferTime = systemTime() - now; 525 mDebugInSwapBuffers = 0; 526 mInvalidRegion.clear(); 527 } 528 } 529 530 void SurfaceFlinger::handleConsoleEvents() 531 { 532 // something to do with the console 533 const DisplayHardware& hw = graphicPlane(0).displayHardware(); 534 535 int what = android_atomic_and(0, &mConsoleSignals); 536 if (what & eConsoleAcquired) { 537 hw.acquireScreen(); 538 } 539 540 if (mDeferReleaseConsole && hw.canDraw()) { 541 // We got the release signal before the acquire signal 542 mDeferReleaseConsole = false; 543 hw.releaseScreen(); 544 } 545 546 if (what & eConsoleReleased) { 547 if (hw.canDraw()) { 548 hw.releaseScreen(); 549 } else { 550 mDeferReleaseConsole = true; 551 } 552 } 553 554 mDirtyRegion.set(hw.bounds()); 555 } 556 557 void SurfaceFlinger::handleTransaction(uint32_t transactionFlags) 558 { 559 Vector< sp<LayerBase> > ditchedLayers; 560 561 { // scope for the lock 562 Mutex::Autolock _l(mStateLock); 563 const nsecs_t now = systemTime(); 564 mDebugInTransaction = now; 565 handleTransactionLocked(transactionFlags, ditchedLayers); 566 mLastTransactionTime = systemTime() - now; 567 mDebugInTransaction = 0; 568 } 569 570 // do this without lock held 571 const size_t count = ditchedLayers.size(); 572 for (size_t i=0 ; i<count ; i++) { 573 if (ditchedLayers[i] != 0) { 574 //LOGD("ditching layer %p", ditchedLayers[i].get()); 575 ditchedLayers[i]->ditch(); 576 } 577 } 578 } 579 580 void SurfaceFlinger::handleTransactionLocked( 581 uint32_t transactionFlags, Vector< sp<LayerBase> >& ditchedLayers) 582 { 583 const LayerVector& currentLayers(mCurrentState.layersSortedByZ); 584 const size_t count = currentLayers.size(); 585 586 /* 587 * Traversal of the children 588 * (perform the transaction for each of them if needed) 589 */ 590 591 const bool layersNeedTransaction = transactionFlags & eTraversalNeeded; 592 if (layersNeedTransaction) { 593 for (size_t i=0 ; i<count ; i++) { 594 const sp<LayerBase>& layer = currentLayers[i]; 595 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded); 596 if (!trFlags) continue; 597 598 const uint32_t flags = layer->doTransaction(0); 599 if (flags & Layer::eVisibleRegion) 600 mVisibleRegionsDirty = true; 601 } 602 } 603 604 /* 605 * Perform our own transaction if needed 606 */ 607 608 if (transactionFlags & eTransactionNeeded) { 609 if (mCurrentState.orientation != mDrawingState.orientation) { 610 // the orientation has changed, recompute all visible regions 611 // and invalidate everything. 612 613 const int dpy = 0; 614 const int orientation = mCurrentState.orientation; 615 const uint32_t type = mCurrentState.orientationType; 616 GraphicPlane& plane(graphicPlane(dpy)); 617 plane.setOrientation(orientation); 618 619 // update the shared control block 620 const DisplayHardware& hw(plane.displayHardware()); 621 volatile display_cblk_t* dcblk = mServerCblk->displays + dpy; 622 dcblk->orientation = orientation; 623 dcblk->w = plane.getWidth(); 624 dcblk->h = plane.getHeight(); 625 626 mVisibleRegionsDirty = true; 627 mDirtyRegion.set(hw.bounds()); 628 } 629 630 if (mCurrentState.freezeDisplay != mDrawingState.freezeDisplay) { 631 // freezing or unfreezing the display -> trigger animation if needed 632 mFreezeDisplay = mCurrentState.freezeDisplay; 633 if (mFreezeDisplay) 634 mFreezeDisplayTime = 0; 635 } 636 637 if (currentLayers.size() > mDrawingState.layersSortedByZ.size()) { 638 // layers have been added 639 mVisibleRegionsDirty = true; 640 } 641 642 // some layers might have been removed, so 643 // we need to update the regions they're exposing. 644 if (mLayersRemoved) { 645 mLayersRemoved = false; 646 mVisibleRegionsDirty = true; 647 const LayerVector& previousLayers(mDrawingState.layersSortedByZ); 648 const size_t count = previousLayers.size(); 649 for (size_t i=0 ; i<count ; i++) { 650 const sp<LayerBase>& layer(previousLayers[i]); 651 if (currentLayers.indexOf( layer ) < 0) { 652 // this layer is not visible anymore 653 ditchedLayers.add(layer); 654 mDirtyRegionRemovedLayer.orSelf(layer->visibleRegionScreen); 655 } 656 } 657 } 658 659 // get rid of all resources we don't need anymore 660 // (layers and clients) 661 free_resources_l(); 662 } 663 664 commitTransaction(); 665 } 666 667 sp<FreezeLock> SurfaceFlinger::getFreezeLock() const 668 { 669 return new FreezeLock(const_cast<SurfaceFlinger *>(this)); 670 } 671 672 void SurfaceFlinger::computeVisibleRegions( 673 LayerVector& currentLayers, Region& dirtyRegion, Region& opaqueRegion) 674 { 675 const GraphicPlane& plane(graphicPlane(0)); 676 const Transform& planeTransform(plane.transform()); 677 const DisplayHardware& hw(plane.displayHardware()); 678 const Region screenRegion(hw.bounds()); 679 680 Region aboveOpaqueLayers; 681 Region aboveCoveredLayers; 682 Region dirty; 683 684 bool secureFrameBuffer = false; 685 686 size_t i = currentLayers.size(); 687 while (i--) { 688 const sp<LayerBase>& layer = currentLayers[i]; 689 layer->validateVisibility(planeTransform); 690 691 // start with the whole surface at its current location 692 const Layer::State& s(layer->drawingState()); 693 694 /* 695 * opaqueRegion: area of a surface that is fully opaque. 696 */ 697 Region opaqueRegion; 698 699 /* 700 * visibleRegion: area of a surface that is visible on screen 701 * and not fully transparent. This is essentially the layer's 702 * footprint minus the opaque regions above it. 703 * Areas covered by a translucent surface are considered visible. 704 */ 705 Region visibleRegion; 706 707 /* 708 * coveredRegion: area of a surface that is covered by all 709 * visible regions above it (which includes the translucent areas). 710 */ 711 Region coveredRegion; 712 713 714 // handle hidden surfaces by setting the visible region to empty 715 if (LIKELY(!(s.flags & ISurfaceComposer::eLayerHidden) && s.alpha)) { 716 const bool translucent = layer->needsBlending(); 717 const Rect bounds(layer->visibleBounds()); 718 visibleRegion.set(bounds); 719 visibleRegion.andSelf(screenRegion); 720 if (!visibleRegion.isEmpty()) { 721 // Remove the transparent area from the visible region 722 if (translucent) { 723 visibleRegion.subtractSelf(layer->transparentRegionScreen); 724 } 725 726 // compute the opaque region 727 const int32_t layerOrientation = layer->getOrientation(); 728 if (s.alpha==255 && !translucent && 729 ((layerOrientation & Transform::ROT_INVALID) == false)) { 730 // the opaque region is the layer's footprint 731 opaqueRegion = visibleRegion; 732 } 733 } 734 } 735 736 // Clip the covered region to the visible region 737 coveredRegion = aboveCoveredLayers.intersect(visibleRegion); 738 739 // Update aboveCoveredLayers for next (lower) layer 740 aboveCoveredLayers.orSelf(visibleRegion); 741 742 // subtract the opaque region covered by the layers above us 743 visibleRegion.subtractSelf(aboveOpaqueLayers); 744 745 // compute this layer's dirty region 746 if (layer->contentDirty) { 747 // we need to invalidate the whole region 748 dirty = visibleRegion; 749 // as well, as the old visible region 750 dirty.orSelf(layer->visibleRegionScreen); 751 layer->contentDirty = false; 752 } else { 753 /* compute the exposed region: 754 * the exposed region consists of two components: 755 * 1) what's VISIBLE now and was COVERED before 756 * 2) what's EXPOSED now less what was EXPOSED before 757 * 758 * note that (1) is conservative, we start with the whole 759 * visible region but only keep what used to be covered by 760 * something -- which mean it may have been exposed. 761 * 762 * (2) handles areas that were not covered by anything but got 763 * exposed because of a resize. 764 */ 765 const Region newExposed = visibleRegion - coveredRegion; 766 const Region oldVisibleRegion = layer->visibleRegionScreen; 767 const Region oldCoveredRegion = layer->coveredRegionScreen; 768 const Region oldExposed = oldVisibleRegion - oldCoveredRegion; 769 dirty = (visibleRegion&oldCoveredRegion) | (newExposed-oldExposed); 770 } 771 dirty.subtractSelf(aboveOpaqueLayers); 772 773 // accumulate to the screen dirty region 774 dirtyRegion.orSelf(dirty); 775 776 // Update aboveOpaqueLayers for next (lower) layer 777 aboveOpaqueLayers.orSelf(opaqueRegion); 778 779 // Store the visible region is screen space 780 layer->setVisibleRegion(visibleRegion); 781 layer->setCoveredRegion(coveredRegion); 782 783 // If a secure layer is partially visible, lock-down the screen! 784 if (layer->isSecure() && !visibleRegion.isEmpty()) { 785 secureFrameBuffer = true; 786 } 787 } 788 789 // invalidate the areas where a layer was removed 790 dirtyRegion.orSelf(mDirtyRegionRemovedLayer); 791 mDirtyRegionRemovedLayer.clear(); 792 793 mSecureFrameBuffer = secureFrameBuffer; 794 opaqueRegion = aboveOpaqueLayers; 795 } 796 797 798 void SurfaceFlinger::commitTransaction() 799 { 800 mDrawingState = mCurrentState; 801 mResizeTransationPending = false; 802 mTransactionCV.broadcast(); 803 } 804 805 void SurfaceFlinger::handlePageFlip() 806 { 807 bool visibleRegions = mVisibleRegionsDirty; 808 LayerVector& currentLayers = const_cast<LayerVector&>(mDrawingState.layersSortedByZ); 809 visibleRegions |= lockPageFlip(currentLayers); 810 811 const DisplayHardware& hw = graphicPlane(0).displayHardware(); 812 const Region screenRegion(hw.bounds()); 813 if (visibleRegions) { 814 Region opaqueRegion; 815 computeVisibleRegions(currentLayers, mDirtyRegion, opaqueRegion); 816 mWormholeRegion = screenRegion.subtract(opaqueRegion); 817 mVisibleRegionsDirty = false; 818 } 819 820 unlockPageFlip(currentLayers); 821 mDirtyRegion.andSelf(screenRegion); 822 } 823 824 bool SurfaceFlinger::lockPageFlip(const LayerVector& currentLayers) 825 { 826 bool recomputeVisibleRegions = false; 827 size_t count = currentLayers.size(); 828 sp<LayerBase> const* layers = currentLayers.array(); 829 for (size_t i=0 ; i<count ; i++) { 830 const sp<LayerBase>& layer = layers[i]; 831 layer->lockPageFlip(recomputeVisibleRegions); 832 } 833 return recomputeVisibleRegions; 834 } 835 836 void SurfaceFlinger::unlockPageFlip(const LayerVector& currentLayers) 837 { 838 const GraphicPlane& plane(graphicPlane(0)); 839 const Transform& planeTransform(plane.transform()); 840 size_t count = currentLayers.size(); 841 sp<LayerBase> const* layers = currentLayers.array(); 842 for (size_t i=0 ; i<count ; i++) { 843 const sp<LayerBase>& layer = layers[i]; 844 layer->unlockPageFlip(planeTransform, mDirtyRegion); 845 } 846 } 847 848 849 void SurfaceFlinger::handleRepaint() 850 { 851 // compute the invalid region 852 mInvalidRegion.orSelf(mDirtyRegion); 853 if (mInvalidRegion.isEmpty()) { 854 // nothing to do 855 return; 856 } 857 858 if (UNLIKELY(mDebugRegion)) { 859 debugFlashRegions(); 860 } 861 862 // set the frame buffer 863 const DisplayHardware& hw(graphicPlane(0).displayHardware()); 864 glMatrixMode(GL_MODELVIEW); 865 glLoadIdentity(); 866 867 uint32_t flags = hw.getFlags(); 868 if ((flags & DisplayHardware::SWAP_RECTANGLE) || 869 (flags & DisplayHardware::BUFFER_PRESERVED)) 870 { 871 // we can redraw only what's dirty, but since SWAP_RECTANGLE only 872 // takes a rectangle, we must make sure to update that whole 873 // rectangle in that case 874 if (flags & DisplayHardware::SWAP_RECTANGLE) { 875 // FIXME: we really should be able to pass a region to 876 // SWAP_RECTANGLE so that we don't have to redraw all this. 877 mDirtyRegion.set(mInvalidRegion.bounds()); 878 } else { 879 // in the BUFFER_PRESERVED case, obviously, we can update only 880 // what's needed and nothing more. 881 // NOTE: this is NOT a common case, as preserving the backbuffer 882 // is costly and usually involves copying the whole update back. 883 } 884 } else { 885 if (flags & DisplayHardware::PARTIAL_UPDATES) { 886 // We need to redraw the rectangle that will be updated 887 // (pushed to the framebuffer). 888 // This is needed because PARTIAL_UPDATES only takes one 889 // rectangle instead of a region (see DisplayHardware::flip()) 890 mDirtyRegion.set(mInvalidRegion.bounds()); 891 } else { 892 // we need to redraw everything (the whole screen) 893 mDirtyRegion.set(hw.bounds()); 894 mInvalidRegion = mDirtyRegion; 895 } 896 } 897 898 // compose all surfaces 899 composeSurfaces(mDirtyRegion); 900 901 // clear the dirty regions 902 mDirtyRegion.clear(); 903 } 904 905 void SurfaceFlinger::composeSurfaces(const Region& dirty) 906 { 907 if (UNLIKELY(!mWormholeRegion.isEmpty())) { 908 // should never happen unless the window manager has a bug 909 // draw something... 910 drawWormhole(); 911 } 912 const SurfaceFlinger& flinger(*this); 913 const LayerVector& drawingLayers(mDrawingState.layersSortedByZ); 914 const size_t count = drawingLayers.size(); 915 sp<LayerBase> const* const layers = drawingLayers.array(); 916 for (size_t i=0 ; i<count ; ++i) { 917 const sp<LayerBase>& layer = layers[i]; 918 const Region& visibleRegion(layer->visibleRegionScreen); 919 if (!visibleRegion.isEmpty()) { 920 const Region clip(dirty.intersect(visibleRegion)); 921 if (!clip.isEmpty()) { 922 layer->draw(clip); 923 } 924 } 925 } 926 } 927 928 void SurfaceFlinger::unlockClients() 929 { 930 const LayerVector& drawingLayers(mDrawingState.layersSortedByZ); 931 const size_t count = drawingLayers.size(); 932 sp<LayerBase> const* const layers = drawingLayers.array(); 933 for (size_t i=0 ; i<count ; ++i) { 934 const sp<LayerBase>& layer = layers[i]; 935 layer->finishPageFlip(); 936 } 937 } 938 939 void SurfaceFlinger::debugFlashRegions() 940 { 941 const DisplayHardware& hw(graphicPlane(0).displayHardware()); 942 const uint32_t flags = hw.getFlags(); 943 944 if (!((flags & DisplayHardware::SWAP_RECTANGLE) || 945 (flags & DisplayHardware::BUFFER_PRESERVED))) { 946 const Region repaint((flags & DisplayHardware::PARTIAL_UPDATES) ? 947 mDirtyRegion.bounds() : hw.bounds()); 948 composeSurfaces(repaint); 949 } 950 951 glDisable(GL_TEXTURE_2D); 952 glDisable(GL_BLEND); 953 glDisable(GL_DITHER); 954 glDisable(GL_SCISSOR_TEST); 955 956 static int toggle = 0; 957 toggle = 1 - toggle; 958 if (toggle) { 959 glColor4x(0x10000, 0, 0x10000, 0x10000); 960 } else { 961 glColor4x(0x10000, 0x10000, 0, 0x10000); 962 } 963 964 Region::const_iterator it = mDirtyRegion.begin(); 965 Region::const_iterator const end = mDirtyRegion.end(); 966 while (it != end) { 967 const Rect& r = *it++; 968 GLfloat vertices[][2] = { 969 { r.left, r.top }, 970 { r.left, r.bottom }, 971 { r.right, r.bottom }, 972 { r.right, r.top } 973 }; 974 glVertexPointer(2, GL_FLOAT, 0, vertices); 975 glDrawArrays(GL_TRIANGLE_FAN, 0, 4); 976 } 977 978 if (mInvalidRegion.isEmpty()) { 979 mDirtyRegion.dump("mDirtyRegion"); 980 mInvalidRegion.dump("mInvalidRegion"); 981 } 982 hw.flip(mInvalidRegion); 983 984 if (mDebugRegion > 1) 985 usleep(mDebugRegion * 1000); 986 987 glEnable(GL_SCISSOR_TEST); 988 //mDirtyRegion.dump("mDirtyRegion"); 989 } 990 991 void SurfaceFlinger::drawWormhole() const 992 { 993 const Region region(mWormholeRegion.intersect(mDirtyRegion)); 994 if (region.isEmpty()) 995 return; 996 997 const DisplayHardware& hw(graphicPlane(0).displayHardware()); 998 const int32_t width = hw.getWidth(); 999 const int32_t height = hw.getHeight(); 1000 1001 glDisable(GL_BLEND); 1002 glDisable(GL_DITHER); 1003 1004 if (LIKELY(!mDebugBackground)) { 1005 glClearColorx(0,0,0,0); 1006 Region::const_iterator it = region.begin(); 1007 Region::const_iterator const end = region.end(); 1008 while (it != end) { 1009 const Rect& r = *it++; 1010 const GLint sy = height - (r.top + r.height()); 1011 glScissor(r.left, sy, r.width(), r.height()); 1012 glClear(GL_COLOR_BUFFER_BIT); 1013 } 1014 } else { 1015 const GLshort vertices[][2] = { { 0, 0 }, { width, 0 }, 1016 { width, height }, { 0, height } }; 1017 const GLshort tcoords[][2] = { { 0, 0 }, { 1, 0 }, { 1, 1 }, { 0, 1 } }; 1018 glVertexPointer(2, GL_SHORT, 0, vertices); 1019 glTexCoordPointer(2, GL_SHORT, 0, tcoords); 1020 glEnableClientState(GL_TEXTURE_COORD_ARRAY); 1021 glEnable(GL_TEXTURE_2D); 1022 glBindTexture(GL_TEXTURE_2D, mWormholeTexName); 1023 glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 1024 glMatrixMode(GL_TEXTURE); 1025 glLoadIdentity(); 1026 glScalef(width*(1.0f/32.0f), height*(1.0f/32.0f), 1); 1027 Region::const_iterator it = region.begin(); 1028 Region::const_iterator const end = region.end(); 1029 while (it != end) { 1030 const Rect& r = *it++; 1031 const GLint sy = height - (r.top + r.height()); 1032 glScissor(r.left, sy, r.width(), r.height()); 1033 glDrawArrays(GL_TRIANGLE_FAN, 0, 4); 1034 } 1035 glDisableClientState(GL_TEXTURE_COORD_ARRAY); 1036 } 1037 } 1038 1039 void SurfaceFlinger::debugShowFPS() const 1040 { 1041 static int mFrameCount; 1042 static int mLastFrameCount = 0; 1043 static nsecs_t mLastFpsTime = 0; 1044 static float mFps = 0; 1045 mFrameCount++; 1046 nsecs_t now = systemTime(); 1047 nsecs_t diff = now - mLastFpsTime; 1048 if (diff > ms2ns(250)) { 1049 mFps = ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff; 1050 mLastFpsTime = now; 1051 mLastFrameCount = mFrameCount; 1052 } 1053 // XXX: mFPS has the value we want 1054 } 1055 1056 status_t SurfaceFlinger::addLayer(const sp<LayerBase>& layer) 1057 { 1058 Mutex::Autolock _l(mStateLock); 1059 addLayer_l(layer); 1060 setTransactionFlags(eTransactionNeeded|eTraversalNeeded); 1061 return NO_ERROR; 1062 } 1063 1064 status_t SurfaceFlinger::removeLayer(const sp<LayerBase>& layer) 1065 { 1066 Mutex::Autolock _l(mStateLock); 1067 status_t err = purgatorizeLayer_l(layer); 1068 if (err == NO_ERROR) 1069 setTransactionFlags(eTransactionNeeded); 1070 return err; 1071 } 1072 1073 status_t SurfaceFlinger::invalidateLayerVisibility(const sp<LayerBase>& layer) 1074 { 1075 layer->forceVisibilityTransaction(); 1076 setTransactionFlags(eTraversalNeeded); 1077 return NO_ERROR; 1078 } 1079 1080 status_t SurfaceFlinger::addLayer_l(const sp<LayerBase>& layer) 1081 { 1082 if (layer == 0) 1083 return BAD_VALUE; 1084 ssize_t i = mCurrentState.layersSortedByZ.add( 1085 layer, &LayerBase::compareCurrentStateZ); 1086 sp<LayerBaseClient> lbc = LayerBase::dynamicCast< LayerBaseClient* >(layer.get()); 1087 if (lbc != 0) { 1088 mLayerMap.add(lbc->serverIndex(), lbc); 1089 } 1090 return NO_ERROR; 1091 } 1092 1093 status_t SurfaceFlinger::removeLayer_l(const sp<LayerBase>& layerBase) 1094 { 1095 ssize_t index = mCurrentState.layersSortedByZ.remove(layerBase); 1096 if (index >= 0) { 1097 mLayersRemoved = true; 1098 sp<LayerBaseClient> layer = 1099 LayerBase::dynamicCast< LayerBaseClient* >(layerBase.get()); 1100 if (layer != 0) { 1101 mLayerMap.removeItem(layer->serverIndex()); 1102 } 1103 return NO_ERROR; 1104 } 1105 return status_t(index); 1106 } 1107 1108 status_t SurfaceFlinger::purgatorizeLayer_l(const sp<LayerBase>& layerBase) 1109 { 1110 // remove the layer from the main list (through a transaction). 1111 ssize_t err = removeLayer_l(layerBase); 1112 1113 layerBase->onRemoved(); 1114 1115 // it's possible that we don't find a layer, because it might 1116 // have been destroyed already -- this is not technically an error 1117 // from the user because there is a race between BClient::destroySurface(), 1118 // ~BClient() and ~ISurface(). 1119 return (err == NAME_NOT_FOUND) ? status_t(NO_ERROR) : err; 1120 } 1121 1122 1123 void SurfaceFlinger::free_resources_l() 1124 { 1125 // free resources associated with disconnected clients 1126 Vector< sp<Client> >& disconnectedClients(mDisconnectedClients); 1127 const size_t count = disconnectedClients.size(); 1128 for (size_t i=0 ; i<count ; i++) { 1129 sp<Client> client = disconnectedClients[i]; 1130 mTokens.release(client->cid); 1131 } 1132 disconnectedClients.clear(); 1133 } 1134 1135 uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags) 1136 { 1137 return android_atomic_and(~flags, &mTransactionFlags) & flags; 1138 } 1139 1140 uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags, nsecs_t delay) 1141 { 1142 uint32_t old = android_atomic_or(flags, &mTransactionFlags); 1143 if ((old & flags)==0) { // wake the server up 1144 if (delay > 0) { 1145 signalDelayedEvent(delay); 1146 } else { 1147 signalEvent(); 1148 } 1149 } 1150 return old; 1151 } 1152 1153 void SurfaceFlinger::openGlobalTransaction() 1154 { 1155 android_atomic_inc(&mTransactionCount); 1156 } 1157 1158 void SurfaceFlinger::closeGlobalTransaction() 1159 { 1160 if (android_atomic_dec(&mTransactionCount) == 1) { 1161 signalEvent(); 1162 1163 // if there is a transaction with a resize, wait for it to 1164 // take effect before returning. 1165 Mutex::Autolock _l(mStateLock); 1166 while (mResizeTransationPending) { 1167 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5)); 1168 if (CC_UNLIKELY(err != NO_ERROR)) { 1169 // just in case something goes wrong in SF, return to the 1170 // called after a few seconds. 1171 LOGW_IF(err == TIMED_OUT, "closeGlobalTransaction timed out!"); 1172 mResizeTransationPending = false; 1173 break; 1174 } 1175 } 1176 } 1177 } 1178 1179 status_t SurfaceFlinger::freezeDisplay(DisplayID dpy, uint32_t flags) 1180 { 1181 if (UNLIKELY(uint32_t(dpy) >= DISPLAY_COUNT)) 1182 return BAD_VALUE; 1183 1184 Mutex::Autolock _l(mStateLock); 1185 mCurrentState.freezeDisplay = 1; 1186 setTransactionFlags(eTransactionNeeded); 1187 1188 // flags is intended to communicate some sort of animation behavior 1189 // (for instance fading) 1190 return NO_ERROR; 1191 } 1192 1193 status_t SurfaceFlinger::unfreezeDisplay(DisplayID dpy, uint32_t flags) 1194 { 1195 if (UNLIKELY(uint32_t(dpy) >= DISPLAY_COUNT)) 1196 return BAD_VALUE; 1197 1198 Mutex::Autolock _l(mStateLock); 1199 mCurrentState.freezeDisplay = 0; 1200 setTransactionFlags(eTransactionNeeded); 1201 1202 // flags is intended to communicate some sort of animation behavior 1203 // (for instance fading) 1204 return NO_ERROR; 1205 } 1206 1207 int SurfaceFlinger::setOrientation(DisplayID dpy, 1208 int orientation, uint32_t flags) 1209 { 1210 if (UNLIKELY(uint32_t(dpy) >= DISPLAY_COUNT)) 1211 return BAD_VALUE; 1212 1213 Mutex::Autolock _l(mStateLock); 1214 if (mCurrentState.orientation != orientation) { 1215 if (uint32_t(orientation)<=eOrientation270 || orientation==42) { 1216 mCurrentState.orientationType = flags; 1217 mCurrentState.orientation = orientation; 1218 setTransactionFlags(eTransactionNeeded); 1219 mTransactionCV.wait(mStateLock); 1220 } else { 1221 orientation = BAD_VALUE; 1222 } 1223 } 1224 return orientation; 1225 } 1226 1227 sp<ISurface> SurfaceFlinger::createSurface(ClientID clientId, int pid, 1228 const String8& name, ISurfaceFlingerClient::surface_data_t* params, 1229 DisplayID d, uint32_t w, uint32_t h, PixelFormat format, 1230 uint32_t flags) 1231 { 1232 sp<LayerBaseClient> layer; 1233 sp<LayerBaseClient::Surface> surfaceHandle; 1234 1235 if (int32_t(w|h) < 0) { 1236 LOGE("createSurface() failed, w or h is negative (w=%d, h=%d)", 1237 int(w), int(h)); 1238 return surfaceHandle; 1239 } 1240 1241 Mutex::Autolock _l(mStateLock); 1242 sp<Client> client = mClientsMap.valueFor(clientId); 1243 if (UNLIKELY(client == 0)) { 1244 LOGE("createSurface() failed, client not found (id=%d)", clientId); 1245 return surfaceHandle; 1246 } 1247 1248 //LOGD("createSurface for pid %d (%d x %d)", pid, w, h); 1249 int32_t id = client->generateId(pid); 1250 if (uint32_t(id) >= NUM_LAYERS_MAX) { 1251 LOGE("createSurface() failed, generateId = %d", id); 1252 return surfaceHandle; 1253 } 1254 1255 switch (flags & eFXSurfaceMask) { 1256 case eFXSurfaceNormal: 1257 if (UNLIKELY(flags & ePushBuffers)) { 1258 layer = createPushBuffersSurfaceLocked(client, d, id, 1259 w, h, flags); 1260 } else { 1261 layer = createNormalSurfaceLocked(client, d, id, 1262 w, h, flags, format); 1263 } 1264 break; 1265 case eFXSurfaceBlur: 1266 layer = createBlurSurfaceLocked(client, d, id, w, h, flags); 1267 break; 1268 case eFXSurfaceDim: 1269 layer = createDimSurfaceLocked(client, d, id, w, h, flags); 1270 break; 1271 } 1272 1273 if (layer != 0) { 1274 layer->setName(name); 1275 setTransactionFlags(eTransactionNeeded); 1276 surfaceHandle = layer->getSurface(); 1277 if (surfaceHandle != 0) { 1278 params->token = surfaceHandle->getToken(); 1279 params->identity = surfaceHandle->getIdentity(); 1280 params->width = w; 1281 params->height = h; 1282 params->format = format; 1283 } 1284 } 1285 1286 return surfaceHandle; 1287 } 1288 1289 sp<LayerBaseClient> SurfaceFlinger::createNormalSurfaceLocked( 1290 const sp<Client>& client, DisplayID display, 1291 int32_t id, uint32_t w, uint32_t h, uint32_t flags, 1292 PixelFormat& format) 1293 { 1294 // initialize the surfaces 1295 switch (format) { // TODO: take h/w into account 1296 case PIXEL_FORMAT_TRANSPARENT: 1297 case PIXEL_FORMAT_TRANSLUCENT: 1298 format = PIXEL_FORMAT_RGBA_8888; 1299 break; 1300 case PIXEL_FORMAT_OPAQUE: 1301 format = PIXEL_FORMAT_RGB_565; 1302 break; 1303 } 1304 1305 sp<Layer> layer = new Layer(this, display, client, id); 1306 status_t err = layer->setBuffers(w, h, format, flags); 1307 if (LIKELY(err == NO_ERROR)) { 1308 layer->initStates(w, h, flags); 1309 addLayer_l(layer); 1310 } else { 1311 LOGE("createNormalSurfaceLocked() failed (%s)", strerror(-err)); 1312 layer.clear(); 1313 } 1314 return layer; 1315 } 1316 1317 sp<LayerBaseClient> SurfaceFlinger::createBlurSurfaceLocked( 1318 const sp<Client>& client, DisplayID display, 1319 int32_t id, uint32_t w, uint32_t h, uint32_t flags) 1320 { 1321 sp<LayerBlur> layer = new LayerBlur(this, display, client, id); 1322 layer->initStates(w, h, flags); 1323 addLayer_l(layer); 1324 return layer; 1325 } 1326 1327 sp<LayerBaseClient> SurfaceFlinger::createDimSurfaceLocked( 1328 const sp<Client>& client, DisplayID display, 1329 int32_t id, uint32_t w, uint32_t h, uint32_t flags) 1330 { 1331 sp<LayerDim> layer = new LayerDim(this, display, client, id); 1332 layer->initStates(w, h, flags); 1333 addLayer_l(layer); 1334 return layer; 1335 } 1336 1337 sp<LayerBaseClient> SurfaceFlinger::createPushBuffersSurfaceLocked( 1338 const sp<Client>& client, DisplayID display, 1339 int32_t id, uint32_t w, uint32_t h, uint32_t flags) 1340 { 1341 sp<LayerBuffer> layer = new LayerBuffer(this, display, client, id); 1342 layer->initStates(w, h, flags); 1343 addLayer_l(layer); 1344 return layer; 1345 } 1346 1347 status_t SurfaceFlinger::removeSurface(SurfaceID index) 1348 { 1349 /* 1350 * called by the window manager, when a surface should be marked for 1351 * destruction. 1352 * 1353 * The surface is removed from the current and drawing lists, but placed 1354 * in the purgatory queue, so it's not destroyed right-away (we need 1355 * to wait for all client's references to go away first). 1356 */ 1357 1358 status_t err = NAME_NOT_FOUND; 1359 Mutex::Autolock _l(mStateLock); 1360 sp<LayerBaseClient> layer = getLayerUser_l(index); 1361 if (layer != 0) { 1362 err = purgatorizeLayer_l(layer); 1363 if (err == NO_ERROR) { 1364 setTransactionFlags(eTransactionNeeded); 1365 } 1366 } 1367 return err; 1368 } 1369 1370 status_t SurfaceFlinger::destroySurface(const sp<LayerBaseClient>& layer) 1371 { 1372 // called by ~ISurface() when all references are gone 1373 1374 class MessageDestroySurface : public MessageBase { 1375 SurfaceFlinger* flinger; 1376 sp<LayerBaseClient> layer; 1377 public: 1378 MessageDestroySurface( 1379 SurfaceFlinger* flinger, const sp<LayerBaseClient>& layer) 1380 : flinger(flinger), layer(layer) { } 1381 virtual bool handler() { 1382 sp<LayerBaseClient> l(layer); 1383 layer.clear(); // clear it outside of the lock; 1384 Mutex::Autolock _l(flinger->mStateLock); 1385 /* 1386 * remove the layer from the current list -- chances are that it's 1387 * not in the list anyway, because it should have been removed 1388 * already upon request of the client (eg: window manager). 1389 * However, a buggy client could have not done that. 1390 * Since we know we don't have any more clients, we don't need 1391 * to use the purgatory. 1392 */ 1393 status_t err = flinger->removeLayer_l(l); 1394 LOGE_IF(err<0 && err != NAME_NOT_FOUND, 1395 "error removing layer=%p (%s)", l.get(), strerror(-err)); 1396 return true; 1397 } 1398 }; 1399 1400 mEventQueue.postMessage( new MessageDestroySurface(this, layer) ); 1401 return NO_ERROR; 1402 } 1403 1404 status_t SurfaceFlinger::setClientState( 1405 ClientID cid, 1406 int32_t count, 1407 const layer_state_t* states) 1408 { 1409 Mutex::Autolock _l(mStateLock); 1410 uint32_t flags = 0; 1411 cid <<= 16; 1412 for (int i=0 ; i<count ; i++) { 1413 const layer_state_t& s = states[i]; 1414 sp<LayerBaseClient> layer(getLayerUser_l(s.surface | cid)); 1415 if (layer != 0) { 1416 const uint32_t what = s.what; 1417 if (what & ePositionChanged) { 1418 if (layer->setPosition(s.x, s.y)) 1419 flags |= eTraversalNeeded; 1420 } 1421 if (what & eLayerChanged) { 1422 if (layer->setLayer(s.z)) { 1423 mCurrentState.layersSortedByZ.reorder( 1424 layer, &Layer::compareCurrentStateZ); 1425 // we need traversal (state changed) 1426 // AND transaction (list changed) 1427 flags |= eTransactionNeeded|eTraversalNeeded; 1428 } 1429 } 1430 if (what & eSizeChanged) { 1431 if (layer->setSize(s.w, s.h)) { 1432 flags |= eTraversalNeeded; 1433 mResizeTransationPending = true; 1434 } 1435 } 1436 if (what & eAlphaChanged) { 1437 if (layer->setAlpha(uint8_t(255.0f*s.alpha+0.5f))) 1438 flags |= eTraversalNeeded; 1439 } 1440 if (what & eMatrixChanged) { 1441 if (layer->setMatrix(s.matrix)) 1442 flags |= eTraversalNeeded; 1443 } 1444 if (what & eTransparentRegionChanged) { 1445 if (layer->setTransparentRegionHint(s.transparentRegion)) 1446 flags |= eTraversalNeeded; 1447 } 1448 if (what & eVisibilityChanged) { 1449 if (layer->setFlags(s.flags, s.mask)) 1450 flags |= eTraversalNeeded; 1451 } 1452 } 1453 } 1454 if (flags) { 1455 setTransactionFlags(flags); 1456 } 1457 return NO_ERROR; 1458 } 1459 1460 sp<LayerBaseClient> SurfaceFlinger::getLayerUser_l(SurfaceID s) const 1461 { 1462 sp<LayerBaseClient> layer = mLayerMap.valueFor(s); 1463 return layer; 1464 } 1465 1466 void SurfaceFlinger::screenReleased(int dpy) 1467 { 1468 // this may be called by a signal handler, we can't do too much in here 1469 android_atomic_or(eConsoleReleased, &mConsoleSignals); 1470 signalEvent(); 1471 } 1472 1473 void SurfaceFlinger::screenAcquired(int dpy) 1474 { 1475 // this may be called by a signal handler, we can't do too much in here 1476 android_atomic_or(eConsoleAcquired, &mConsoleSignals); 1477 signalEvent(); 1478 } 1479 1480 status_t SurfaceFlinger::dump(int fd, const Vector<String16>& args) 1481 { 1482 const size_t SIZE = 1024; 1483 char buffer[SIZE]; 1484 String8 result; 1485 if (!mDump.checkCalling()) { 1486 snprintf(buffer, SIZE, "Permission Denial: " 1487 "can't dump SurfaceFlinger from pid=%d, uid=%d\n", 1488 IPCThreadState::self()->getCallingPid(), 1489 IPCThreadState::self()->getCallingUid()); 1490 result.append(buffer); 1491 } else { 1492 1493 // figure out if we're stuck somewhere 1494 const nsecs_t now = systemTime(); 1495 const nsecs_t inSwapBuffers(mDebugInSwapBuffers); 1496 const nsecs_t inTransaction(mDebugInTransaction); 1497 nsecs_t inSwapBuffersDuration = (inSwapBuffers) ? now-inSwapBuffers : 0; 1498 nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0; 1499 1500 // Try to get the main lock, but don't insist if we can't 1501 // (this would indicate SF is stuck, but we want to be able to 1502 // print something in dumpsys). 1503 int retry = 3; 1504 while (mStateLock.tryLock()<0 && --retry>=0) { 1505 usleep(1000000); 1506 } 1507 const bool locked(retry >= 0); 1508 if (!locked) { 1509 snprintf(buffer, SIZE, 1510 "SurfaceFlinger appears to be unresponsive, " 1511 "dumping anyways (no locks held)\n"); 1512 result.append(buffer); 1513 } 1514 1515 size_t s = mClientsMap.size(); 1516 char name[64]; 1517 for (size_t i=0 ; i<s ; i++) { 1518 sp<Client> client = mClientsMap.valueAt(i); 1519 sprintf(name, " Client (id=0x%08x)", client->cid); 1520 client->dump(name); 1521 } 1522 const LayerVector& currentLayers = mCurrentState.layersSortedByZ; 1523 const size_t count = currentLayers.size(); 1524 for (size_t i=0 ; i<count ; i++) { 1525 /*** LayerBase ***/ 1526 const sp<LayerBase>& layer = currentLayers[i]; 1527 const Layer::State& s = layer->drawingState(); 1528 snprintf(buffer, SIZE, 1529 "+ %s %p\n" 1530 " " 1531 "z=%9d, pos=(%4d,%4d), size=(%4d,%4d), " 1532 "needsBlending=%1d, needsDithering=%1d, invalidate=%1d, " 1533 "alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n", 1534 layer->getTypeID(), layer.get(), 1535 s.z, layer->tx(), layer->ty(), s.w, s.h, 1536 layer->needsBlending(), layer->needsDithering(), 1537 layer->contentDirty, 1538 s.alpha, s.flags, 1539 s.transform[0][0], s.transform[0][1], 1540 s.transform[1][0], s.transform[1][1]); 1541 result.append(buffer); 1542 buffer[0] = 0; 1543 /*** LayerBaseClient ***/ 1544 sp<LayerBaseClient> lbc = 1545 LayerBase::dynamicCast< LayerBaseClient* >(layer.get()); 1546 if (lbc != 0) { 1547 sp<Client> client(lbc->client.promote()); 1548 snprintf(buffer, SIZE, 1549 " name=%s\n", lbc->getName().string()); 1550 result.append(buffer); 1551 snprintf(buffer, SIZE, 1552 " id=0x%08x, client=0x%08x, identity=%u\n", 1553 lbc->clientIndex(), client.get() ? client->cid : 0, 1554 lbc->getIdentity()); 1555 1556 result.append(buffer); 1557 buffer[0] = 0; 1558 } 1559 /*** Layer ***/ 1560 sp<Layer> l = LayerBase::dynamicCast< Layer* >(layer.get()); 1561 if (l != 0) { 1562 SharedBufferStack::Statistics stats = l->lcblk->getStats(); 1563 result.append( l->lcblk->dump(" ") ); 1564 sp<const GraphicBuffer> buf0(l->getBuffer(0)); 1565 sp<const GraphicBuffer> buf1(l->getBuffer(1)); 1566 uint32_t w0=0, h0=0, s0=0; 1567 uint32_t w1=0, h1=0, s1=0; 1568 if (buf0 != 0) { 1569 w0 = buf0->getWidth(); 1570 h0 = buf0->getHeight(); 1571 s0 = buf0->getStride(); 1572 } 1573 if (buf1 != 0) { 1574 w1 = buf1->getWidth(); 1575 h1 = buf1->getHeight(); 1576 s1 = buf1->getStride(); 1577 } 1578 snprintf(buffer, SIZE, 1579 " " 1580 "format=%2d, [%3ux%3u:%3u] [%3ux%3u:%3u]," 1581 " freezeLock=%p, dq-q-time=%u us\n", 1582 l->pixelFormat(), 1583 w0, h0, s0, w1, h1, s1, 1584 l->getFreezeLock().get(), stats.totalTime); 1585 result.append(buffer); 1586 buffer[0] = 0; 1587 } 1588 s.transparentRegion.dump(result, "transparentRegion"); 1589 layer->transparentRegionScreen.dump(result, "transparentRegionScreen"); 1590 layer->visibleRegionScreen.dump(result, "visibleRegionScreen"); 1591 } 1592 mWormholeRegion.dump(result, "WormholeRegion"); 1593 const DisplayHardware& hw(graphicPlane(0).displayHardware()); 1594 snprintf(buffer, SIZE, 1595 " display frozen: %s, freezeCount=%d, orientation=%d, canDraw=%d\n", 1596 mFreezeDisplay?"yes":"no", mFreezeCount, 1597 mCurrentState.orientation, hw.canDraw()); 1598 result.append(buffer); 1599 snprintf(buffer, SIZE, 1600 " last eglSwapBuffers() time: %f us\n" 1601 " last transaction time : %f us\n", 1602 mLastSwapBufferTime/1000.0, mLastTransactionTime/1000.0); 1603 result.append(buffer); 1604 if (inSwapBuffersDuration || !locked) { 1605 snprintf(buffer, SIZE, " eglSwapBuffers time: %f us\n", 1606 inSwapBuffersDuration/1000.0); 1607 result.append(buffer); 1608 } 1609 if (inTransactionDuration || !locked) { 1610 snprintf(buffer, SIZE, " transaction time: %f us\n", 1611 inTransactionDuration/1000.0); 1612 result.append(buffer); 1613 } 1614 snprintf(buffer, SIZE, " client count: %d\n", mClientsMap.size()); 1615 result.append(buffer); 1616 const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get()); 1617 alloc.dump(result); 1618 1619 if (locked) { 1620 mStateLock.unlock(); 1621 } 1622 } 1623 write(fd, result.string(), result.size()); 1624 return NO_ERROR; 1625 } 1626 1627 status_t SurfaceFlinger::onTransact( 1628 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 1629 { 1630 switch (code) { 1631 case CREATE_CONNECTION: 1632 case OPEN_GLOBAL_TRANSACTION: 1633 case CLOSE_GLOBAL_TRANSACTION: 1634 case SET_ORIENTATION: 1635 case FREEZE_DISPLAY: 1636 case UNFREEZE_DISPLAY: 1637 case BOOT_FINISHED: 1638 { 1639 // codes that require permission check 1640 IPCThreadState* ipc = IPCThreadState::self(); 1641 const int pid = ipc->getCallingPid(); 1642 const int uid = ipc->getCallingUid(); 1643 if ((uid != AID_GRAPHICS) && !mAccessSurfaceFlinger.check(pid, uid)) { 1644 LOGE("Permission Denial: " 1645 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid); 1646 return PERMISSION_DENIED; 1647 } 1648 } 1649 } 1650 status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags); 1651 if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) { 1652 CHECK_INTERFACE(ISurfaceComposer, data, reply); 1653 if (UNLIKELY(!mHardwareTest.checkCalling())) { 1654 IPCThreadState* ipc = IPCThreadState::self(); 1655 const int pid = ipc->getCallingPid(); 1656 const int uid = ipc->getCallingUid(); 1657 LOGE("Permission Denial: " 1658 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid); 1659 return PERMISSION_DENIED; 1660 } 1661 int n; 1662 switch (code) { 1663 case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE 1664 return NO_ERROR; 1665 case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE 1666 return NO_ERROR; 1667 case 1002: // SHOW_UPDATES 1668 n = data.readInt32(); 1669 mDebugRegion = n ? n : (mDebugRegion ? 0 : 1); 1670 return NO_ERROR; 1671 case 1003: // SHOW_BACKGROUND 1672 n = data.readInt32(); 1673 mDebugBackground = n ? 1 : 0; 1674 return NO_ERROR; 1675 case 1004:{ // repaint everything 1676 Mutex::Autolock _l(mStateLock); 1677 const DisplayHardware& hw(graphicPlane(0).displayHardware()); 1678 mDirtyRegion.set(hw.bounds()); // careful that's not thread-safe 1679 signalEvent(); 1680 return NO_ERROR; 1681 } 1682 case 1005:{ // force transaction 1683 setTransactionFlags(eTransactionNeeded|eTraversalNeeded); 1684 return NO_ERROR; 1685 } 1686 case 1007: // set mFreezeCount 1687 mFreezeCount = data.readInt32(); 1688 mFreezeDisplayTime = 0; 1689 return NO_ERROR; 1690 case 1010: // interrogate. 1691 reply->writeInt32(0); 1692 reply->writeInt32(0); 1693 reply->writeInt32(mDebugRegion); 1694 reply->writeInt32(mDebugBackground); 1695 return NO_ERROR; 1696 case 1013: { 1697 Mutex::Autolock _l(mStateLock); 1698 const DisplayHardware& hw(graphicPlane(0).displayHardware()); 1699 reply->writeInt32(hw.getPageFlipCount()); 1700 } 1701 return NO_ERROR; 1702 } 1703 } 1704 return err; 1705 } 1706 1707 // --------------------------------------------------------------------------- 1708 #if 0 1709 #pragma mark - 1710 #endif 1711 1712 Client::Client(ClientID clientID, const sp<SurfaceFlinger>& flinger) 1713 : ctrlblk(0), cid(clientID), mPid(0), mBitmap(0), mFlinger(flinger) 1714 { 1715 const int pgsize = getpagesize(); 1716 const int cblksize = ((sizeof(SharedClient)+(pgsize-1))&~(pgsize-1)); 1717 1718 mCblkHeap = new MemoryHeapBase(cblksize, 0, 1719 "SurfaceFlinger Client control-block"); 1720 1721 ctrlblk = static_cast<SharedClient *>(mCblkHeap->getBase()); 1722 if (ctrlblk) { // construct the shared structure in-place. 1723 new(ctrlblk) SharedClient; 1724 } 1725 } 1726 1727 Client::~Client() { 1728 if (ctrlblk) { 1729 ctrlblk->~SharedClient(); // destroy our shared-structure. 1730 } 1731 } 1732 1733 int32_t Client::generateId(int pid) 1734 { 1735 const uint32_t i = clz( ~mBitmap ); 1736 if (i >= NUM_LAYERS_MAX) { 1737 return NO_MEMORY; 1738 } 1739 mPid = pid; 1740 mInUse.add(uint8_t(i)); 1741 mBitmap |= 1<<(31-i); 1742 return i; 1743 } 1744 1745 status_t Client::bindLayer(const sp<LayerBaseClient>& layer, int32_t id) 1746 { 1747 ssize_t idx = mInUse.indexOf(id); 1748 if (idx < 0) 1749 return NAME_NOT_FOUND; 1750 return mLayers.insertAt(layer, idx); 1751 } 1752 1753 void Client::free(int32_t id) 1754 { 1755 ssize_t idx = mInUse.remove(uint8_t(id)); 1756 if (idx >= 0) { 1757 mBitmap &= ~(1<<(31-id)); 1758 mLayers.removeItemsAt(idx); 1759 } 1760 } 1761 1762 bool Client::isValid(int32_t i) const { 1763 return (uint32_t(i)<NUM_LAYERS_MAX) && (mBitmap & (1<<(31-i))); 1764 } 1765 1766 sp<LayerBaseClient> Client::getLayerUser(int32_t i) const { 1767 sp<LayerBaseClient> lbc; 1768 ssize_t idx = mInUse.indexOf(uint8_t(i)); 1769 if (idx >= 0) { 1770 lbc = mLayers[idx].promote(); 1771 LOGE_IF(lbc==0, "getLayerUser(i=%d), idx=%d is dead", int(i), int(idx)); 1772 } 1773 return lbc; 1774 } 1775 1776 void Client::dump(const char* what) 1777 { 1778 } 1779 1780 // --------------------------------------------------------------------------- 1781 #if 0 1782 #pragma mark - 1783 #endif 1784 1785 BClient::BClient(SurfaceFlinger *flinger, ClientID cid, const sp<IMemoryHeap>& cblk) 1786 : mId(cid), mFlinger(flinger), mCblk(cblk) 1787 { 1788 } 1789 1790 BClient::~BClient() { 1791 // destroy all resources attached to this client 1792 mFlinger->destroyConnection(mId); 1793 } 1794 1795 sp<IMemoryHeap> BClient::getControlBlock() const { 1796 return mCblk; 1797 } 1798 1799 sp<ISurface> BClient::createSurface( 1800 ISurfaceFlingerClient::surface_data_t* params, int pid, 1801 const String8& name, 1802 DisplayID display, uint32_t w, uint32_t h, PixelFormat format, 1803 uint32_t flags) 1804 { 1805 return mFlinger->createSurface(mId, pid, name, params, display, w, h, 1806 format, flags); 1807 } 1808 1809 status_t BClient::destroySurface(SurfaceID sid) 1810 { 1811 sid |= (mId << 16); // add the client-part to id 1812 return mFlinger->removeSurface(sid); 1813 } 1814 1815 status_t BClient::setState(int32_t count, const layer_state_t* states) 1816 { 1817 return mFlinger->setClientState(mId, count, states); 1818 } 1819 1820 // --------------------------------------------------------------------------- 1821 1822 GraphicPlane::GraphicPlane() 1823 : mHw(0) 1824 { 1825 } 1826 1827 GraphicPlane::~GraphicPlane() { 1828 delete mHw; 1829 } 1830 1831 bool GraphicPlane::initialized() const { 1832 return mHw ? true : false; 1833 } 1834 1835 int GraphicPlane::getWidth() const { 1836 return mWidth; 1837 } 1838 1839 int GraphicPlane::getHeight() const { 1840 return mHeight; 1841 } 1842 1843 void GraphicPlane::setDisplayHardware(DisplayHardware *hw) 1844 { 1845 mHw = hw; 1846 1847 // initialize the display orientation transform. 1848 // it's a constant that should come from the display driver. 1849 int displayOrientation = ISurfaceComposer::eOrientationDefault; 1850 char property[PROPERTY_VALUE_MAX]; 1851 if (property_get("ro.sf.hwrotation", property, NULL) > 0) { 1852 //displayOrientation 1853 switch (atoi(property)) { 1854 case 90: 1855 displayOrientation = ISurfaceComposer::eOrientation90; 1856 break; 1857 case 270: 1858 displayOrientation = ISurfaceComposer::eOrientation270; 1859 break; 1860 } 1861 } 1862 1863 const float w = hw->getWidth(); 1864 const float h = hw->getHeight(); 1865 GraphicPlane::orientationToTransfrom(displayOrientation, w, h, 1866 &mDisplayTransform); 1867 if (displayOrientation & ISurfaceComposer::eOrientationSwapMask) { 1868 mDisplayWidth = h; 1869 mDisplayHeight = w; 1870 } else { 1871 mDisplayWidth = w; 1872 mDisplayHeight = h; 1873 } 1874 1875 setOrientation(ISurfaceComposer::eOrientationDefault); 1876 } 1877 1878 status_t GraphicPlane::orientationToTransfrom( 1879 int orientation, int w, int h, Transform* tr) 1880 { 1881 uint32_t flags = 0; 1882 switch (orientation) { 1883 case ISurfaceComposer::eOrientationDefault: 1884 flags = Transform::ROT_0; 1885 break; 1886 case ISurfaceComposer::eOrientation90: 1887 flags = Transform::ROT_90; 1888 break; 1889 case ISurfaceComposer::eOrientation180: 1890 flags = Transform::ROT_180; 1891 break; 1892 case ISurfaceComposer::eOrientation270: 1893 flags = Transform::ROT_270; 1894 break; 1895 default: 1896 return BAD_VALUE; 1897 } 1898 tr->set(flags, w, h); 1899 return NO_ERROR; 1900 } 1901 1902 status_t GraphicPlane::setOrientation(int orientation) 1903 { 1904 // If the rotation can be handled in hardware, this is where 1905 // the magic should happen. 1906 1907 const DisplayHardware& hw(displayHardware()); 1908 const float w = mDisplayWidth; 1909 const float h = mDisplayHeight; 1910 mWidth = int(w); 1911 mHeight = int(h); 1912 1913 Transform orientationTransform; 1914 GraphicPlane::orientationToTransfrom(orientation, w, h, 1915 &orientationTransform); 1916 if (orientation & ISurfaceComposer::eOrientationSwapMask) { 1917 mWidth = int(h); 1918 mHeight = int(w); 1919 } 1920 1921 mOrientation = orientation; 1922 mGlobalTransform = mDisplayTransform * orientationTransform; 1923 return NO_ERROR; 1924 } 1925 1926 const DisplayHardware& GraphicPlane::displayHardware() const { 1927 return *mHw; 1928 } 1929 1930 const Transform& GraphicPlane::transform() const { 1931 return mGlobalTransform; 1932 } 1933 1934 EGLDisplay GraphicPlane::getEGLDisplay() const { 1935 return mHw->getEGLDisplay(); 1936 } 1937 1938 // --------------------------------------------------------------------------- 1939 1940 }; // namespace android 1941
