SurfaceFlinger.cpp revision 24a42e9f54e971a17b829e85681c68d60a178d26
1edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project/* 2edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project * Copyright (C) 2007 The Android Open Source Project 3edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project * 4edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project * Licensed under the Apache License, Version 2.0 (the "License"); 5edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project * you may not use this file except in compliance with the License. 6edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project * You may obtain a copy of the License at 7edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project * 8edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project * http://www.apache.org/licenses/LICENSE-2.0 9edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project * 10edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project * Unless required by applicable law or agreed to in writing, software 11edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project * distributed under the License is distributed on an "AS IS" BASIS, 12edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project * See the License for the specific language governing permissions and 14edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project * limitations under the License. 15edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project */ 16edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 171c8e95cf86f2182986385bc1ee85f13f425f3a3aJamie Gennis#define ATRACE_TAG ATRACE_TAG_GRAPHICS 181c8e95cf86f2182986385bc1ee85f13f425f3a3aJamie Gennis 19edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#include <stdint.h> 20921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian#include <sys/types.h> 21edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#include <errno.h> 22edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#include <math.h> 2363f165fd6b86d04be94d4023e845e98560504a96Keun young Park#include <dlfcn.h> 2486efcc0cbc1d94250b72ef1f2ea8700a04cd2781Greg Hackmann#include <inttypes.h> 25b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall#include <stdatomic.h> 26921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian 27921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian#include <EGL/egl.h> 28edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 29edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#include <cutils/log.h> 30edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#include <cutils/properties.h> 31edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 32c5b2c0bf8007562536b822eb060fc54a01f8e08bMathias Agopian#include <binder/IPCThreadState.h> 33c5b2c0bf8007562536b822eb060fc54a01f8e08bMathias Agopian#include <binder/IServiceManager.h> 347303c6bf1a8b00a0e7d8165d774a1f259b4ccda9Mathias Agopian#include <binder/MemoryHeapBase.h> 3599b49840d309727678b77403d6cc9f920111623fMathias Agopian#include <binder/PermissionCache.h> 367303c6bf1a8b00a0e7d8165d774a1f259b4ccda9Mathias Agopian 37c666cae2d5995097ec49a87e375e2afdd92802b7Mathias Agopian#include <ui/DisplayInfo.h> 3867d8bd66aaf04805cb8f2616ba964141b865e3b9Lajos Molnar#include <ui/DisplayStatInfo.h> 39c666cae2d5995097ec49a87e375e2afdd92802b7Mathias Agopian 40921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian#include <gui/BitTube.h> 411a4d883dcc1725892bfb5c28dec255a233186524Jamie Gennis#include <gui/BufferQueue.h> 424803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden#include <gui/GuiConfig.h> 431a4d883dcc1725892bfb5c28dec255a233186524Jamie Gennis#include <gui/IDisplayEventConnection.h> 44e3c697fb929c856b59fa56a8e05a2a7eba187c3dMathias Agopian#include <gui/Surface.h> 45392edd88cb63d71a21a86a02cf9c56ac97637128Jamie Gennis#include <gui/GraphicBufferAlloc.h> 46921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian 47921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian#include <ui/GraphicBufferAllocator.h> 48921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian#include <ui/PixelFormat.h> 494803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden#include <ui/UiConfig.h> 50d0566bc26fcf6ca396118701fa11900b627f2c09Mathias Agopian 51cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian#include <utils/misc.h> 52edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#include <utils/String8.h> 53edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#include <utils/String16.h> 54edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#include <utils/StopWatch.h> 551c8e95cf86f2182986385bc1ee85f13f425f3a3aJamie Gennis#include <utils/Trace.h> 56edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 57921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian#include <private/android_filesystem_config.h> 58ca08833d5ea99130797e10ad68a651b50e99da74Mathias Agopian#include <private/gui/SyncFeatures.h> 59edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 603e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian#include "Client.h" 61edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#include "clz.h" 623e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian#include "Colorizer.h" 6390ac799241f077a7b7e6c1875fd933864c8dd2a7Mathias Agopian#include "DdmConnection.h" 640f2f5ff75b7b48ceb64270655ee6b62d09bf4d00Mathias Agopian#include "DisplayDevice.h" 65faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis#include "DispSync.h" 66d1700756ec9520c3fba22f9a14fd064a6e288810Jamie Gennis#include "EventControlThread.h" 67d0566bc26fcf6ca396118701fa11900b627f2c09Mathias Agopian#include "EventThread.h" 68edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#include "Layer.h" 69edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#include "LayerDim.h" 70edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#include "SurfaceFlinger.h" 71edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 72a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian#include "DisplayHardware/FramebufferSurface.h" 73a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian#include "DisplayHardware/HWComposer.h" 7499c7dbb24994df2f3e175f7b25dd2c9dd92a72f0Jesse Hall#include "DisplayHardware/VirtualDisplaySurface.h" 75edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 76ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian#include "Effects/Daltonizer.h" 77ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian 78875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian#include "RenderEngine/RenderEngine.h" 79ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian#include <cutils/compiler.h> 80875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian 81edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#define DISPLAY_COUNT 1 82edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 83fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian/* 84fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian * DEBUG_SCREENSHOTS: set to true to check that screenshots are not all 85fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian * black pixels. 86fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian */ 87fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian#define DEBUG_SCREENSHOTS false 88fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian 89ca08833d5ea99130797e10ad68a651b50e99da74Mathias AgopianEGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name); 90ca08833d5ea99130797e10ad68a651b50e99da74Mathias Agopian 91edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Projectnamespace android { 92faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 93faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// This is the phase offset in nanoseconds of the software vsync event 94faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// relative to the vsync event reported by HWComposer. The software vsync 95faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// event is when SurfaceFlinger and Choreographer-based applications run each 96faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// frame. 97faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// 98faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// This phase offset allows adjustment of the minimum latency from application 99faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// wake-up (by Choregographer) time to the time at which the resulting window 100faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// image is displayed. This value may be either positive (after the HW vsync) 101faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// or negative (before the HW vsync). Setting it to 0 will result in a 102faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// minimum latency of two vsync periods because the app and SurfaceFlinger 103faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// will run just after the HW vsync. Setting it to a positive number will 104faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// result in the minimum latency being: 105faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// 106faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// (2 * VSYNC_PERIOD - (vsyncPhaseOffsetNs % VSYNC_PERIOD)) 107faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// 108faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// Note that reducing this latency makes it more likely for the applications 109faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// to not have their window content image ready in time. When this happens 110faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// the latency will end up being an additional vsync period, and animations 111faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// will hiccup. Therefore, this latency should be tuned somewhat 112faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// conservatively (or at least with awareness of the trade-off being made). 113faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennisstatic const int64_t vsyncPhaseOffsetNs = VSYNC_EVENT_PHASE_OFFSET_NS; 114faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 1150a645cc5a935e67a8d1effc7679a838160b971d8Jamie Gennis// This is the phase offset at which SurfaceFlinger's composition runs. 1160a645cc5a935e67a8d1effc7679a838160b971d8Jamie Gennisstatic const int64_t sfVsyncPhaseOffsetNs = SF_VSYNC_EVENT_PHASE_OFFSET_NS; 1170a645cc5a935e67a8d1effc7679a838160b971d8Jamie Gennis 118edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project// --------------------------------------------------------------------------- 119edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 12099b49840d309727678b77403d6cc9f920111623fMathias Agopianconst String16 sHardwareTest("android.permission.HARDWARE_TEST"); 12199b49840d309727678b77403d6cc9f920111623fMathias Agopianconst String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER"); 12299b49840d309727678b77403d6cc9f920111623fMathias Agopianconst String16 sReadFramebuffer("android.permission.READ_FRAME_BUFFER"); 12399b49840d309727678b77403d6cc9f920111623fMathias Agopianconst String16 sDump("android.permission.DUMP"); 12499b49840d309727678b77403d6cc9f920111623fMathias Agopian 12599b49840d309727678b77403d6cc9f920111623fMathias Agopian// --------------------------------------------------------------------------- 12699b49840d309727678b77403d6cc9f920111623fMathias Agopian 127edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source ProjectSurfaceFlinger::SurfaceFlinger() 1284f4f0943489d9113c66ac22b58cfba8c21dfa879Mathias Agopian : BnSurfaceComposer(), 129edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project mTransactionFlags(0), 1302d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis mTransactionPending(false), 1312d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis mAnimTransactionPending(false), 132076b1cc3a9b90aa5b381a1ed268ca0b548444c9bMathias Agopian mLayersRemoved(false), 13352bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian mRepaintEverything(0), 134875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian mRenderEngine(NULL), 135edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project mBootTime(systemTime()), 136edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project mVisibleRegionsDirty(false), 137a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian mHwWorkListDirty(false), 1384b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis mAnimCompositionPending(false), 139edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project mDebugRegion(0), 1408afb7e39a83a3e31170612d562eb08508e328388Mathias Agopian mDebugDDMS(0), 14173d3ba9e50be1014aa21ec4bbdc874be394accb4Mathias Agopian mDebugDisableHWC(0), 142a45836466c301d49d8df286b5317dfa99cb83b70Mathias Agopian mDebugDisableTransformHint(0), 1439795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian mDebugInSwapBuffers(0), 1449795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian mLastSwapBufferTime(0), 1459795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian mDebugInTransaction(0), 1469795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian mLastTransactionTime(0), 147ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian mBootFinished(false), 148faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mPrimaryHWVsyncEnabled(false), 149948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall mHWVsyncAvailable(false), 1509c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette mDaltonize(false), 1519c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette mHasColorMatrix(false) 152edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 153a19954ab377b46dbcb9cbe8a6ab6d458f2e32bcaSteve Block ALOGI("SurfaceFlinger is starting"); 154edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 155edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project // debugging stuff... 156edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project char value[PROPERTY_VALUE_MAX]; 1578afb7e39a83a3e31170612d562eb08508e328388Mathias Agopian 158b4b1730abb7824dc084468c4942f010d94a7e039Mathias Agopian property_get("ro.bq.gpu_to_cpu_unsupported", value, "0"); 15950210b9a8d19cb90fc283d8d99e46cd34ac17d2eMathias Agopian mGpuToCpuSupported = !atoi(value); 160b4b1730abb7824dc084468c4942f010d94a7e039Mathias Agopian 161edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project property_get("debug.sf.showupdates", value, "0"); 162edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project mDebugRegion = atoi(value); 1638afb7e39a83a3e31170612d562eb08508e328388Mathias Agopian 1648afb7e39a83a3e31170612d562eb08508e328388Mathias Agopian property_get("debug.sf.ddms", value, "0"); 1658afb7e39a83a3e31170612d562eb08508e328388Mathias Agopian mDebugDDMS = atoi(value); 1668afb7e39a83a3e31170612d562eb08508e328388Mathias Agopian if (mDebugDDMS) { 16763f165fd6b86d04be94d4023e845e98560504a96Keun young Park if (!startDdmConnection()) { 16863f165fd6b86d04be94d4023e845e98560504a96Keun young Park // start failed, and DDMS debugging not enabled 16963f165fd6b86d04be94d4023e845e98560504a96Keun young Park mDebugDDMS = 0; 17063f165fd6b86d04be94d4023e845e98560504a96Keun young Park } 1718afb7e39a83a3e31170612d562eb08508e328388Mathias Agopian } 172c1d359d42b753fcc2426d66a0f782f7c300893bcMathias Agopian ALOGI_IF(mDebugRegion, "showupdates enabled"); 173c1d359d42b753fcc2426d66a0f782f7c300893bcMathias Agopian ALOGI_IF(mDebugDDMS, "DDMS debugging enabled"); 174edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 175edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 17699ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopianvoid SurfaceFlinger::onFirstRef() 17799ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian{ 17899ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian mEventQueue.init(this); 17999ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian} 18099ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian 181edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source ProjectSurfaceFlinger::~SurfaceFlinger() 182edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 183a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY); 184a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); 185a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian eglTerminate(display); 186edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 187edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 188c701401f8cec2e5309f8b57e2b97baced5093274Dan Stozavoid SurfaceFlinger::binderDied(const wp<IBinder>& /* who */) 18999ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian{ 19099ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian // the window manager died on us. prepare its eulogy. 19199ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian 19213a082e160c2d1d8006b93a555a57035213d568bAndy McFadden // restore initial conditions (default device unblank, etc) 19313a082e160c2d1d8006b93a555a57035213d568bAndy McFadden initializeDisplays(); 19499ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian 19599ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian // restart the boot-animation 196a67e418e1fda219f6cc0a7e420bcf5cc4f9fe710Mathias Agopian startBootAnim(); 19799ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian} 19899ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian 1997e27f05739c8a2655cf0f7faea35614ce0a50278Mathias Agopiansp<ISurfaceComposerClient> SurfaceFlinger::createConnection() 200edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 20196f0819f81293076e652792794a961543e6750d7Mathias Agopian sp<ISurfaceComposerClient> bclient; 20296f0819f81293076e652792794a961543e6750d7Mathias Agopian sp<Client> client(new Client(this)); 20396f0819f81293076e652792794a961543e6750d7Mathias Agopian status_t err = client->initCheck(); 20496f0819f81293076e652792794a961543e6750d7Mathias Agopian if (err == NO_ERROR) { 20596f0819f81293076e652792794a961543e6750d7Mathias Agopian bclient = client; 206edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 207edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project return bclient; 208edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 209edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 210dd3cb84cfbe8068790c6233b5829fae9c4a0ee93Jamie Gennissp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName, 211dd3cb84cfbe8068790c6233b5829fae9c4a0ee93Jamie Gennis bool secure) 212e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian{ 213e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian class DisplayToken : public BBinder { 214e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian sp<SurfaceFlinger> flinger; 215e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian virtual ~DisplayToken() { 216e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian // no more references, this display must be terminated 217e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian Mutex::Autolock _l(flinger->mStateLock); 218e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flinger->mCurrentState.displays.removeItem(this); 219e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flinger->setTransactionFlags(eDisplayTransactionNeeded); 220e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 221e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian public: 222e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian DisplayToken(const sp<SurfaceFlinger>& flinger) 223e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian : flinger(flinger) { 224e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 225e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian }; 226e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian 227e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian sp<BBinder> token = new DisplayToken(this); 228e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian 229e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian Mutex::Autolock _l(mStateLock); 2303ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias Agopian DisplayDeviceState info(DisplayDevice::DISPLAY_VIRTUAL); 2318dfa92fef9759a881e96ee58d59875d35023aab9Andy McFadden info.displayName = displayName; 232dd3cb84cfbe8068790c6233b5829fae9c4a0ee93Jamie Gennis info.isSecure = secure; 233e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian mCurrentState.displays.add(token, info); 234e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian 235e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian return token; 236e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian} 237e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian 2386c913be9ca95fd6b556d056e165a4ba6dc69795bJesse Hallvoid SurfaceFlinger::destroyDisplay(const sp<IBinder>& display) { 2396c913be9ca95fd6b556d056e165a4ba6dc69795bJesse Hall Mutex::Autolock _l(mStateLock); 2406c913be9ca95fd6b556d056e165a4ba6dc69795bJesse Hall 2416c913be9ca95fd6b556d056e165a4ba6dc69795bJesse Hall ssize_t idx = mCurrentState.displays.indexOfKey(display); 2426c913be9ca95fd6b556d056e165a4ba6dc69795bJesse Hall if (idx < 0) { 2436c913be9ca95fd6b556d056e165a4ba6dc69795bJesse Hall ALOGW("destroyDisplay: invalid display token"); 2446c913be9ca95fd6b556d056e165a4ba6dc69795bJesse Hall return; 2456c913be9ca95fd6b556d056e165a4ba6dc69795bJesse Hall } 2466c913be9ca95fd6b556d056e165a4ba6dc69795bJesse Hall 2476c913be9ca95fd6b556d056e165a4ba6dc69795bJesse Hall const DisplayDeviceState& info(mCurrentState.displays.valueAt(idx)); 2486c913be9ca95fd6b556d056e165a4ba6dc69795bJesse Hall if (!info.isVirtualDisplay()) { 2496c913be9ca95fd6b556d056e165a4ba6dc69795bJesse Hall ALOGE("destroyDisplay called for non-virtual display"); 2506c913be9ca95fd6b556d056e165a4ba6dc69795bJesse Hall return; 2516c913be9ca95fd6b556d056e165a4ba6dc69795bJesse Hall } 2526c913be9ca95fd6b556d056e165a4ba6dc69795bJesse Hall 2536c913be9ca95fd6b556d056e165a4ba6dc69795bJesse Hall mCurrentState.displays.removeItemsAt(idx); 2546c913be9ca95fd6b556d056e165a4ba6dc69795bJesse Hall setTransactionFlags(eDisplayTransactionNeeded); 2556c913be9ca95fd6b556d056e165a4ba6dc69795bJesse Hall} 2566c913be9ca95fd6b556d056e165a4ba6dc69795bJesse Hall 257692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hallvoid SurfaceFlinger::createBuiltinDisplayLocked(DisplayDevice::DisplayType type) { 258692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall ALOGW_IF(mBuiltinDisplays[type], 259692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall "Overwriting display token for display type %d", type); 260692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall mBuiltinDisplays[type] = new BBinder(); 261692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall DisplayDeviceState info(type); 262692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall // All non-virtual displays are currently considered secure. 263692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall info.isSecure = true; 264692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall mCurrentState.displays.add(mBuiltinDisplays[type], info); 265692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall} 266692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall 267e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopiansp<IBinder> SurfaceFlinger::getBuiltInDisplay(int32_t id) { 2689e663de4fe1dcc872373ee530c60a375624671c3Jesse Hall if (uint32_t(id) >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) { 269e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian ALOGE("getDefaultDisplay: id=%d is not a valid default display id", id); 270e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian return NULL; 271e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 272692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall return mBuiltinDisplays[id]; 273e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian} 274e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian 2759a78c90cd46b2a3bd637b056873149d3b94384b4Jamie Gennissp<IGraphicBufferAlloc> SurfaceFlinger::createGraphicBufferAlloc() 2769a78c90cd46b2a3bd637b056873149d3b94384b4Jamie Gennis{ 2779a78c90cd46b2a3bd637b056873149d3b94384b4Jamie Gennis sp<GraphicBufferAlloc> gba(new GraphicBufferAlloc()); 2789a78c90cd46b2a3bd637b056873149d3b94384b4Jamie Gennis return gba; 2799a78c90cd46b2a3bd637b056873149d3b94384b4Jamie Gennis} 280b7e930db175c192464cebdeb49eb56cf6dd60114Mathias Agopian 281edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Projectvoid SurfaceFlinger::bootFinished() 282edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 283edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project const nsecs_t now = systemTime(); 284edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project const nsecs_t duration = now - mBootTime; 285a19954ab377b46dbcb9cbe8a6ab6d458f2e32bcaSteve Block ALOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) ); 2863330b203039dea366d4981db1408a460134b2d2cMathias Agopian mBootFinished = true; 2871f339ff3875afad128a8e16ee6395c5fad295826Mathias Agopian 2881f339ff3875afad128a8e16ee6395c5fad295826Mathias Agopian // wait patiently for the window manager death 2891f339ff3875afad128a8e16ee6395c5fad295826Mathias Agopian const String16 name("window"); 2901f339ff3875afad128a8e16ee6395c5fad295826Mathias Agopian sp<IBinder> window(defaultServiceManager()->getService(name)); 2911f339ff3875afad128a8e16ee6395c5fad295826Mathias Agopian if (window != 0) { 292921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian window->linkToDeath(static_cast<IBinder::DeathRecipient*>(this)); 2931f339ff3875afad128a8e16ee6395c5fad295826Mathias Agopian } 2941f339ff3875afad128a8e16ee6395c5fad295826Mathias Agopian 2951f339ff3875afad128a8e16ee6395c5fad295826Mathias Agopian // stop boot animation 296a67e418e1fda219f6cc0a7e420bcf5cc4f9fe710Mathias Agopian // formerly we would just kill the process, but we now ask it to exit so it 297a67e418e1fda219f6cc0a7e420bcf5cc4f9fe710Mathias Agopian // can choose where to stop the animation. 298a67e418e1fda219f6cc0a7e420bcf5cc4f9fe710Mathias Agopian property_set("service.bootanim.exit", "1"); 299edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 300edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 3013f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopianvoid SurfaceFlinger::deleteTextureAsync(uint32_t texture) { 302921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian class MessageDestroyGLTexture : public MessageBase { 3033f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian RenderEngine& engine; 3043f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian uint32_t texture; 305921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian public: 3063f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian MessageDestroyGLTexture(RenderEngine& engine, uint32_t texture) 3073f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian : engine(engine), texture(texture) { 308921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian } 309921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian virtual bool handler() { 3103f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian engine.deleteTextures(1, &texture); 311921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian return true; 312921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian } 313921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian }; 3143f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian postMessageAsync(new MessageDestroyGLTexture(getRenderEngine(), texture)); 315921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian} 316921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian 317faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennisclass DispSyncSource : public VSyncSource, private DispSync::Callback { 318faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennispublic: 3195167ec68fed047bf65b1eb0c6091534682135eefAndy McFadden DispSyncSource(DispSync* dispSync, nsecs_t phaseOffset, bool traceVsync, 3205167ec68fed047bf65b1eb0c6091534682135eefAndy McFadden const char* label) : 3210a645cc5a935e67a8d1effc7679a838160b971d8Jamie Gennis mValue(0), 3220a645cc5a935e67a8d1effc7679a838160b971d8Jamie Gennis mPhaseOffset(phaseOffset), 3230a645cc5a935e67a8d1effc7679a838160b971d8Jamie Gennis mTraceVsync(traceVsync), 3245167ec68fed047bf65b1eb0c6091534682135eefAndy McFadden mVsyncOnLabel(String8::format("VsyncOn-%s", label)), 3255167ec68fed047bf65b1eb0c6091534682135eefAndy McFadden mVsyncEventLabel(String8::format("VSYNC-%s", label)), 3260a645cc5a935e67a8d1effc7679a838160b971d8Jamie Gennis mDispSync(dispSync) {} 327faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 328faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis virtual ~DispSyncSource() {} 329faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 330faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis virtual void setVSyncEnabled(bool enable) { 331faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis // Do NOT lock the mutex here so as to avoid any mutex ordering issues 332faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis // with locking it in the onDispSyncEvent callback. 333faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (enable) { 3340a645cc5a935e67a8d1effc7679a838160b971d8Jamie Gennis status_t err = mDispSync->addEventListener(mPhaseOffset, 335faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis static_cast<DispSync::Callback*>(this)); 336faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (err != NO_ERROR) { 337faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis ALOGE("error registering vsync callback: %s (%d)", 338faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis strerror(-err), err); 339faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 3405167ec68fed047bf65b1eb0c6091534682135eefAndy McFadden //ATRACE_INT(mVsyncOnLabel.string(), 1); 341faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } else { 342faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis status_t err = mDispSync->removeEventListener( 343faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis static_cast<DispSync::Callback*>(this)); 344faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (err != NO_ERROR) { 345faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis ALOGE("error unregistering vsync callback: %s (%d)", 346faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis strerror(-err), err); 347faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 3485167ec68fed047bf65b1eb0c6091534682135eefAndy McFadden //ATRACE_INT(mVsyncOnLabel.string(), 0); 349faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 350faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 351faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 352faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis virtual void setCallback(const sp<VSyncSource::Callback>& callback) { 353faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis Mutex::Autolock lock(mMutex); 354faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mCallback = callback; 355faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 356faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 357faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennisprivate: 358faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis virtual void onDispSyncEvent(nsecs_t when) { 359faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis sp<VSyncSource::Callback> callback; 360faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis { 361faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis Mutex::Autolock lock(mMutex); 362faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis callback = mCallback; 363a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian 3640a645cc5a935e67a8d1effc7679a838160b971d8Jamie Gennis if (mTraceVsync) { 3650a645cc5a935e67a8d1effc7679a838160b971d8Jamie Gennis mValue = (mValue + 1) % 2; 3665167ec68fed047bf65b1eb0c6091534682135eefAndy McFadden ATRACE_INT(mVsyncEventLabel.string(), mValue); 3670a645cc5a935e67a8d1effc7679a838160b971d8Jamie Gennis } 368faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 369faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 370faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (callback != NULL) { 371faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis callback->onVSyncEvent(when); 372faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 373faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 374faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 375faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis int mValue; 376faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 3770a645cc5a935e67a8d1effc7679a838160b971d8Jamie Gennis const nsecs_t mPhaseOffset; 3780a645cc5a935e67a8d1effc7679a838160b971d8Jamie Gennis const bool mTraceVsync; 3795167ec68fed047bf65b1eb0c6091534682135eefAndy McFadden const String8 mVsyncOnLabel; 3805167ec68fed047bf65b1eb0c6091534682135eefAndy McFadden const String8 mVsyncEventLabel; 3810a645cc5a935e67a8d1effc7679a838160b971d8Jamie Gennis 382faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis DispSync* mDispSync; 383faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis sp<VSyncSource::Callback> mCallback; 384faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis Mutex mMutex; 385faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis}; 386faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 387faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennisvoid SurfaceFlinger::init() { 388a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian ALOGI( "SurfaceFlinger's main thread ready to run. " 389a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian "Initializing graphics H/W..."); 390a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian 391692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall Mutex::Autolock _l(mStateLock); 392692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall 393b0d1dd36f104c0b581674adc7f830cbf44b7db06Andy McFadden // initialize EGL for the default display 39434a09ba1efd706323a15633da5044b352988eb5fJesse Hall mEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY); 39534a09ba1efd706323a15633da5044b352988eb5fJesse Hall eglInitialize(mEGLDisplay, NULL, NULL); 396a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian 397b0d1dd36f104c0b581674adc7f830cbf44b7db06Andy McFadden // Initialize the H/W composer object. There may or may not be an 398b0d1dd36f104c0b581674adc7f830cbf44b7db06Andy McFadden // actual hardware composer underneath. 399b0d1dd36f104c0b581674adc7f830cbf44b7db06Andy McFadden mHwc = new HWComposer(this, 400b0d1dd36f104c0b581674adc7f830cbf44b7db06Andy McFadden *static_cast<HWComposer::EventHandler *>(this)); 401b0d1dd36f104c0b581674adc7f830cbf44b7db06Andy McFadden 402875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian // get a RenderEngine for the given display / config (can't fail) 40305f8c703d4a050669ff8f406be3a9dc2357935f7Jesse Hall mRenderEngine = RenderEngine::create(mEGLDisplay, mHwc->getVisualID()); 404875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian 405875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian // retrieve the EGL context that was selected/created 406875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian mEGLContext = mRenderEngine->getEGLContext(); 407a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian 408da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian LOG_ALWAYS_FATAL_IF(mEGLContext == EGL_NO_CONTEXT, 409da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian "couldn't create EGLContext"); 410da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian 411cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian // initialize our non-virtual displays 4129e663de4fe1dcc872373ee530c60a375624671c3Jesse Hall for (size_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) { 413f5a33928349bebc8eebc9f466618997e98c24e68Mathias Agopian DisplayDevice::DisplayType type((DisplayDevice::DisplayType)i); 414f5a33928349bebc8eebc9f466618997e98c24e68Mathias Agopian // set-up the displays that are already connected 4159e2463e71796964cfaa06bf09a880875ac3537bcMathias Agopian if (mHwc->isConnected(i) || type==DisplayDevice::DISPLAY_PRIMARY) { 416dd3cb84cfbe8068790c6233b5829fae9c4a0ee93Jamie Gennis // All non-virtual displays are currently considered secure. 417dd3cb84cfbe8068790c6233b5829fae9c4a0ee93Jamie Gennis bool isSecure = true; 418692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall createBuiltinDisplayLocked(type); 419692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall wp<IBinder> token = mBuiltinDisplays[i]; 420692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall 421b9b088375d33a87b201cdbe18be71802e2607717Dan Stoza sp<IGraphicBufferProducer> producer; 422b9b088375d33a87b201cdbe18be71802e2607717Dan Stoza sp<IGraphicBufferConsumer> consumer; 423b9b088375d33a87b201cdbe18be71802e2607717Dan Stoza BufferQueue::createBufferQueue(&producer, &consumer, 424b9b088375d33a87b201cdbe18be71802e2607717Dan Stoza new GraphicBufferAlloc()); 425b9b088375d33a87b201cdbe18be71802e2607717Dan Stoza 426b9b088375d33a87b201cdbe18be71802e2607717Dan Stoza sp<FramebufferSurface> fbs = new FramebufferSurface(*mHwc, i, 427b9b088375d33a87b201cdbe18be71802e2607717Dan Stoza consumer); 42819e872912af66c53a4350afcc333bbafaf6a2294Jesse Hall int32_t hwcId = allocateHwcDisplayId(type); 429f5a33928349bebc8eebc9f466618997e98c24e68Mathias Agopian sp<DisplayDevice> hw = new DisplayDevice(this, 43019e872912af66c53a4350afcc333bbafaf6a2294Jesse Hall type, hwcId, mHwc->getFormat(hwcId), isSecure, token, 431b9b088375d33a87b201cdbe18be71802e2607717Dan Stoza fbs, producer, 43205f8c703d4a050669ff8f406be3a9dc2357935f7Jesse Hall mRenderEngine->getEGLConfig()); 433f5a33928349bebc8eebc9f466618997e98c24e68Mathias Agopian if (i > DisplayDevice::DISPLAY_PRIMARY) { 434c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden // FIXME: currently we don't get blank/unblank requests 435f5a33928349bebc8eebc9f466618997e98c24e68Mathias Agopian // for displays other than the main display, so we always 436f5a33928349bebc8eebc9f466618997e98c24e68Mathias Agopian // assume a connected display is unblanked. 43786efcc0cbc1d94250b72ef1f2ea8700a04cd2781Greg Hackmann ALOGD("marking display %zu as acquired/unblanked", i); 4382c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani hw->setPowerMode(HWC_POWER_MODE_NORMAL); 439f5a33928349bebc8eebc9f466618997e98c24e68Mathias Agopian } 440f5a33928349bebc8eebc9f466618997e98c24e68Mathias Agopian mDisplays.add(token, hw); 441f5a33928349bebc8eebc9f466618997e98c24e68Mathias Agopian } 442e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 443cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian 444a6bb107434ad36739c21e1f72ac8d0107808a7b9Mathias Agopian // make the GLContext current so that we can create textures when creating Layers 445a6bb107434ad36739c21e1f72ac8d0107808a7b9Mathias Agopian // (which may happens before we render something) 446a6bb107434ad36739c21e1f72ac8d0107808a7b9Mathias Agopian getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext); 447a6bb107434ad36739c21e1f72ac8d0107808a7b9Mathias Agopian 448028508cad5ef63ef9fbd42c14e76658e4fd9ebf2Mathias Agopian // start the EventThread 4490a645cc5a935e67a8d1effc7679a838160b971d8Jamie Gennis sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync, 4505167ec68fed047bf65b1eb0c6091534682135eefAndy McFadden vsyncPhaseOffsetNs, true, "app"); 451faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mEventThread = new EventThread(vsyncSrc); 4520a645cc5a935e67a8d1effc7679a838160b971d8Jamie Gennis sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync, 4535167ec68fed047bf65b1eb0c6091534682135eefAndy McFadden sfVsyncPhaseOffsetNs, true, "sf"); 4540a645cc5a935e67a8d1effc7679a838160b971d8Jamie Gennis mSFEventThread = new EventThread(sfVsyncSrc); 4550a645cc5a935e67a8d1effc7679a838160b971d8Jamie Gennis mEventQueue.setEventThread(mSFEventThread); 456028508cad5ef63ef9fbd42c14e76658e4fd9ebf2Mathias Agopian 457d1700756ec9520c3fba22f9a14fd064a6e288810Jamie Gennis mEventControlThread = new EventControlThread(this); 458d1700756ec9520c3fba22f9a14fd064a6e288810Jamie Gennis mEventControlThread->run("EventControl", PRIORITY_URGENT_DISPLAY); 459d1700756ec9520c3fba22f9a14fd064a6e288810Jamie Gennis 460faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis // set a fake vsync period if there is no HWComposer 461faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (mHwc->initCheck() != NO_ERROR) { 462faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mPrimaryDispSync.setPeriod(16666667); 463faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 464faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 46592a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // initialize our drawing state 46692a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian mDrawingState = mCurrentState; 4678630320433bd15aca239522e54e711ef6372ab07Mathias Agopian 46813a082e160c2d1d8006b93a555a57035213d568bAndy McFadden // set initial conditions (e.g. unblank default device) 46913a082e160c2d1d8006b93a555a57035213d568bAndy McFadden initializeDisplays(); 47013a082e160c2d1d8006b93a555a57035213d568bAndy McFadden 471a1ecca920e15ce04fe56ebf4f1b52ba711f9eb2dMathias Agopian // start boot animation 472a67e418e1fda219f6cc0a7e420bcf5cc4f9fe710Mathias Agopian startBootAnim(); 473edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 474edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 4753ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias Agopianint32_t SurfaceFlinger::allocateHwcDisplayId(DisplayDevice::DisplayType type) { 4769e663de4fe1dcc872373ee530c60a375624671c3Jesse Hall return (uint32_t(type) < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) ? 4773ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias Agopian type : mHwc->allocateDisplayId(); 4783ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias Agopian} 4793ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias Agopian 480a67e418e1fda219f6cc0a7e420bcf5cc4f9fe710Mathias Agopianvoid SurfaceFlinger::startBootAnim() { 481a67e418e1fda219f6cc0a7e420bcf5cc4f9fe710Mathias Agopian // start boot animation 482a67e418e1fda219f6cc0a7e420bcf5cc4f9fe710Mathias Agopian property_set("service.bootanim.exit", "0"); 483a67e418e1fda219f6cc0a7e420bcf5cc4f9fe710Mathias Agopian property_set("ctl.start", "bootanim"); 484a67e418e1fda219f6cc0a7e420bcf5cc4f9fe710Mathias Agopian} 485a67e418e1fda219f6cc0a7e420bcf5cc4f9fe710Mathias Agopian 486875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopiansize_t SurfaceFlinger::getMaxTextureSize() const { 487875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian return mRenderEngine->getMaxTextureSize(); 488a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian} 489a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian 490875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopiansize_t SurfaceFlinger::getMaxViewportDims() const { 491875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian return mRenderEngine->getMaxViewportDims(); 492a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian} 493a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian 494edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project// ---------------------------------------------------------------------------- 495d0566bc26fcf6ca396118701fa11900b627f2c09Mathias Agopian 496582270d69db94286a248bd829f1ae6f910d45124Jamie Gennisbool SurfaceFlinger::authenticateSurfaceTexture( 4972adaf04fab35cf47c824d74d901b54094e01ccd3Andy McFadden const sp<IGraphicBufferProducer>& bufferProducer) const { 498134f0422866e8985188ed10dfbdcb8e6c34b87f7Jamie Gennis Mutex::Autolock _l(mStateLock); 499097ca275f4717a2c47a5d49f302ed2b72c8a1370Marco Nelissen sp<IBinder> surfaceTextureBinder(IInterface::asBinder(bufferProducer)); 5006710604286401d4205c27235a252dd0e5008cc08Mathias Agopian return mGraphicBufferProducerList.indexOf(surfaceTextureBinder) >= 0; 501134f0422866e8985188ed10dfbdcb8e6c34b87f7Jamie Gennis} 502134f0422866e8985188ed10dfbdcb8e6c34b87f7Jamie Gennis 5037f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stozastatus_t SurfaceFlinger::getDisplayConfigs(const sp<IBinder>& display, 5047f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza Vector<DisplayInfo>* configs) { 5057f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza if (configs == NULL) { 5067f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza return BAD_VALUE; 5077f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza } 5087f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza 509692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall int32_t type = NAME_NOT_FOUND; 5109e663de4fe1dcc872373ee530c60a375624671c3Jesse Hall for (int i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) { 511692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall if (display == mBuiltinDisplays[i]) { 5121604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian type = i; 5131604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian break; 5141604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian } 5151604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian } 5161604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian 5171604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian if (type < 0) { 5181604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian return type; 519c666cae2d5995097ec49a87e375e2afdd92802b7Mathias Agopian } 5208b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian 5218b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian // TODO: Not sure if display density should handled by SF any longer 5228b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian class Density { 5238b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian static int getDensityFromProperty(char const* propName) { 5248b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian char property[PROPERTY_VALUE_MAX]; 5258b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian int density = 0; 5268b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian if (property_get(propName, property, NULL) > 0) { 5278b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian density = atoi(property); 5288b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian } 5298b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian return density; 5308b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian } 5318b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian public: 5328b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian static int getEmuDensity() { 5338b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian return getDensityFromProperty("qemu.sf.lcd_density"); } 5348b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian static int getBuildDensity() { 5358b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian return getDensityFromProperty("ro.sf.lcd_density"); } 5368b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian }; 5371604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian 5387f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza configs->clear(); 5397f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza 5407f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza const Vector<HWComposer::DisplayConfig>& hwConfigs = 5417f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza getHwComposer().getConfigs(type); 5427f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza for (size_t c = 0; c < hwConfigs.size(); ++c) { 5437f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza const HWComposer::DisplayConfig& hwConfig = hwConfigs[c]; 5447f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza DisplayInfo info = DisplayInfo(); 5457f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza 5467f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza float xdpi = hwConfig.xdpi; 5477f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza float ydpi = hwConfig.ydpi; 5487f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza 5497f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza if (type == DisplayDevice::DISPLAY_PRIMARY) { 5507f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza // The density of the device is provided by a build property 5517f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza float density = Density::getBuildDensity() / 160.0f; 5527f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza if (density == 0) { 5537f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza // the build doesn't provide a density -- this is wrong! 5547f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza // use xdpi instead 5557f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza ALOGE("ro.sf.lcd_density must be defined as a build property"); 5567f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza density = xdpi / 160.0f; 5577f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza } 5587f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza if (Density::getEmuDensity()) { 5597f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza // if "qemu.sf.lcd_density" is specified, it overrides everything 5607f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza xdpi = ydpi = density = Density::getEmuDensity(); 5617f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza density /= 160.0f; 5627f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza } 5637f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza info.density = density; 5647f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza 5657f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza // TODO: this needs to go away (currently needed only by webkit) 5667f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza sp<const DisplayDevice> hw(getDefaultDisplayDevice()); 5677f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza info.orientation = hw->getOrientation(); 5687f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza } else { 5697f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza // TODO: where should this value come from? 5707f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza static const int TV_DENSITY = 213; 5717f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza info.density = TV_DENSITY / 160.0f; 5727f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza info.orientation = 0; 5731604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian } 5747f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza 5757f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza info.w = hwConfig.width; 5767f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza info.h = hwConfig.height; 5777f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza info.xdpi = xdpi; 5787f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza info.ydpi = ydpi; 5797f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza info.fps = float(1e9 / hwConfig.refresh); 58091b2ca8562763c981c4ce93148db80adb51d0cb6Andy McFadden info.appVsyncOffset = VSYNC_EVENT_PHASE_OFFSET_NS; 58191b2ca8562763c981c4ce93148db80adb51d0cb6Andy McFadden 58291b2ca8562763c981c4ce93148db80adb51d0cb6Andy McFadden // This is how far in advance a buffer must be queued for 58391b2ca8562763c981c4ce93148db80adb51d0cb6Andy McFadden // presentation at a given time. If you want a buffer to appear 58491b2ca8562763c981c4ce93148db80adb51d0cb6Andy McFadden // on the screen at time N, you must submit the buffer before 58591b2ca8562763c981c4ce93148db80adb51d0cb6Andy McFadden // (N - presentationDeadline). 58691b2ca8562763c981c4ce93148db80adb51d0cb6Andy McFadden // 58791b2ca8562763c981c4ce93148db80adb51d0cb6Andy McFadden // Normally it's one full refresh period (to give SF a chance to 58891b2ca8562763c981c4ce93148db80adb51d0cb6Andy McFadden // latch the buffer), but this can be reduced by configuring a 58991b2ca8562763c981c4ce93148db80adb51d0cb6Andy McFadden // DispSync offset. Any additional delays introduced by the hardware 59091b2ca8562763c981c4ce93148db80adb51d0cb6Andy McFadden // composer or panel must be accounted for here. 59191b2ca8562763c981c4ce93148db80adb51d0cb6Andy McFadden // 59291b2ca8562763c981c4ce93148db80adb51d0cb6Andy McFadden // We add an additional 1ms to allow for processing time and 59391b2ca8562763c981c4ce93148db80adb51d0cb6Andy McFadden // differences between the ideal and actual refresh rate. 59491b2ca8562763c981c4ce93148db80adb51d0cb6Andy McFadden info.presentationDeadline = 59591b2ca8562763c981c4ce93148db80adb51d0cb6Andy McFadden hwConfig.refresh - SF_VSYNC_EVENT_PHASE_OFFSET_NS + 1000000; 5967f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza 5977f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza // All non-virtual displays are currently considered secure. 5987f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza info.secure = true; 5997f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza 6007f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza configs->push_back(info); 6018b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian } 6028b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian 6037f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza return NO_ERROR; 6047f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza} 605dd3cb84cfbe8068790c6233b5829fae9c4a0ee93Jamie Gennis 60689fd4f7fa6bd17ce5400979c3b9e5ba0bf7e919eAndreas Gampestatus_t SurfaceFlinger::getDisplayStats(const sp<IBinder>& /* display */, 60767d8bd66aaf04805cb8f2616ba964141b865e3b9Lajos Molnar DisplayStatInfo* stats) { 60867d8bd66aaf04805cb8f2616ba964141b865e3b9Lajos Molnar if (stats == NULL) { 60967d8bd66aaf04805cb8f2616ba964141b865e3b9Lajos Molnar return BAD_VALUE; 61067d8bd66aaf04805cb8f2616ba964141b865e3b9Lajos Molnar } 61167d8bd66aaf04805cb8f2616ba964141b865e3b9Lajos Molnar 61267d8bd66aaf04805cb8f2616ba964141b865e3b9Lajos Molnar // FIXME for now we always return stats for the primary display 61367d8bd66aaf04805cb8f2616ba964141b865e3b9Lajos Molnar memset(stats, 0, sizeof(*stats)); 61467d8bd66aaf04805cb8f2616ba964141b865e3b9Lajos Molnar stats->vsyncTime = mPrimaryDispSync.computeNextRefresh(0); 61567d8bd66aaf04805cb8f2616ba964141b865e3b9Lajos Molnar stats->vsyncPeriod = mPrimaryDispSync.getPeriod(); 61667d8bd66aaf04805cb8f2616ba964141b865e3b9Lajos Molnar return NO_ERROR; 61767d8bd66aaf04805cb8f2616ba964141b865e3b9Lajos Molnar} 61867d8bd66aaf04805cb8f2616ba964141b865e3b9Lajos Molnar 6196c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentineint SurfaceFlinger::getActiveConfig(const sp<IBinder>& display) { 62024a42e9f54e971a17b829e85681c68d60a178d26Dan Stoza sp<DisplayDevice> device(getDisplayDevice(display)); 62124a42e9f54e971a17b829e85681c68d60a178d26Dan Stoza if (device != NULL) { 62224a42e9f54e971a17b829e85681c68d60a178d26Dan Stoza return device->getActiveConfig(); 62324a42e9f54e971a17b829e85681c68d60a178d26Dan Stoza } 62424a42e9f54e971a17b829e85681c68d60a178d26Dan Stoza return BAD_VALUE; 6257f7da32569f8e0b3d383a40b95f8ac1d55afd801Dan Stoza} 626dd3cb84cfbe8068790c6233b5829fae9c4a0ee93Jamie Gennis 6276c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentinevoid SurfaceFlinger::setActiveConfigInternal(const sp<DisplayDevice>& hw, int mode) { 6286c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine ALOGD("Set active config mode=%d, type=%d flinger=%p", mode, hw->getDisplayType(), 6296c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine this); 6306c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine int32_t type = hw->getDisplayType(); 6316c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine int currentMode = hw->getActiveConfig(); 6326c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine 6336c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine if (mode == currentMode) { 6346c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine ALOGD("Screen type=%d is already mode=%d", hw->getDisplayType(), mode); 6356c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine return; 6366c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine } 6376c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine 6386c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine if (type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) { 6396c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine ALOGW("Trying to set config for virtual display"); 6406c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine return; 6416c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine } 6426c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine 6436c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine hw->setActiveConfig(mode); 6446c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine getHwComposer().setActiveConfig(type, mode); 6456c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine} 6466c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine 6476c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentinestatus_t SurfaceFlinger::setActiveConfig(const sp<IBinder>& display, int mode) { 6486c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine class MessageSetActiveConfig: public MessageBase { 6496c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine SurfaceFlinger& mFlinger; 6506c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine sp<IBinder> mDisplay; 6516c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine int mMode; 6526c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine public: 6536c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine MessageSetActiveConfig(SurfaceFlinger& flinger, const sp<IBinder>& disp, 6546c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine int mode) : 6556c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine mFlinger(flinger), mDisplay(disp) { mMode = mode; } 6566c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine virtual bool handler() { 6577306c670eb3ddb471d983a7458eb9f522afd0763Michael Lentine Vector<DisplayInfo> configs; 6587306c670eb3ddb471d983a7458eb9f522afd0763Michael Lentine mFlinger.getDisplayConfigs(mDisplay, &configs); 65989fd4f7fa6bd17ce5400979c3b9e5ba0bf7e919eAndreas Gampe if(mMode < 0 || static_cast<size_t>(mMode) >= configs.size()) { 6609ae79d869a37633fa956a4f16f3fa45b23c189f1Michael Lentine ALOGE("Attempt to set active config = %d for display with %zu configs", 6617306c670eb3ddb471d983a7458eb9f522afd0763Michael Lentine mMode, configs.size()); 6627306c670eb3ddb471d983a7458eb9f522afd0763Michael Lentine } 6636c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay)); 6646c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine if (hw == NULL) { 6656c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine ALOGE("Attempt to set active config = %d for null display %p", 6667306c670eb3ddb471d983a7458eb9f522afd0763Michael Lentine mMode, mDisplay.get()); 6676c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine } else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) { 6686c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine ALOGW("Attempt to set active config = %d for virtual display", 6696c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine mMode); 6706c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine } else { 6716c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine mFlinger.setActiveConfigInternal(hw, mMode); 6726c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine } 6736c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine return true; 6746c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine } 6756c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine }; 6766c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine sp<MessageBase> msg = new MessageSetActiveConfig(*this, display, mode); 6776c9e34a98a63033b80bd1c24c7aa1304f912f10aMichael Lentine postMessageSync(msg); 678888c822c4cb6976aab9256c58bae9e17e3e55c5cMathias Agopian return NO_ERROR; 679c666cae2d5995097ec49a87e375e2afdd92802b7Mathias Agopian} 680c666cae2d5995097ec49a87e375e2afdd92802b7Mathias Agopian 681d85084b2b65828442eafaff9b811e9b6c9ca9fadSvetoslavstatus_t SurfaceFlinger::clearAnimationFrameStats() { 682d85084b2b65828442eafaff9b811e9b6c9ca9fadSvetoslav Mutex::Autolock _l(mStateLock); 683d85084b2b65828442eafaff9b811e9b6c9ca9fadSvetoslav mAnimFrameTracker.clearStats(); 684d85084b2b65828442eafaff9b811e9b6c9ca9fadSvetoslav return NO_ERROR; 685d85084b2b65828442eafaff9b811e9b6c9ca9fadSvetoslav} 686d85084b2b65828442eafaff9b811e9b6c9ca9fadSvetoslav 687d85084b2b65828442eafaff9b811e9b6c9ca9fadSvetoslavstatus_t SurfaceFlinger::getAnimationFrameStats(FrameStats* outStats) const { 688d85084b2b65828442eafaff9b811e9b6c9ca9fadSvetoslav Mutex::Autolock _l(mStateLock); 689d85084b2b65828442eafaff9b811e9b6c9ca9fadSvetoslav mAnimFrameTracker.getStats(outStats); 690d85084b2b65828442eafaff9b811e9b6c9ca9fadSvetoslav return NO_ERROR; 691d85084b2b65828442eafaff9b811e9b6c9ca9fadSvetoslav} 692d85084b2b65828442eafaff9b811e9b6c9ca9fadSvetoslav 693d0566bc26fcf6ca396118701fa11900b627f2c09Mathias Agopian// ---------------------------------------------------------------------------- 694d0566bc26fcf6ca396118701fa11900b627f2c09Mathias Agopian 695d0566bc26fcf6ca396118701fa11900b627f2c09Mathias Agopiansp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection() { 6968aedd4737d6ce8548d2fd5def65b1e1737283821Mathias Agopian return mEventThread->createEventConnection(); 697bb641244d7d73312dc65b8e338df18b22e335107Mathias Agopian} 698bb641244d7d73312dc65b8e338df18b22e335107Mathias Agopian 699edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project// ---------------------------------------------------------------------------- 70099ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian 70199ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopianvoid SurfaceFlinger::waitForEvent() { 70299ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian mEventQueue.waitMessage(); 70399ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian} 70499ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian 70599ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopianvoid SurfaceFlinger::signalTransaction() { 70699ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian mEventQueue.invalidate(); 70799ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian} 70899ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian 70999ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopianvoid SurfaceFlinger::signalLayerUpdate() { 71099ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian mEventQueue.invalidate(); 71199ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian} 71299ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian 71399ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopianvoid SurfaceFlinger::signalRefresh() { 71499ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian mEventQueue.refresh(); 71599ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian} 71699ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian 71799ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopianstatus_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg, 718c701401f8cec2e5309f8b57e2b97baced5093274Dan Stoza nsecs_t reltime, uint32_t /* flags */) { 71999ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian return mEventQueue.postMessage(msg, reltime); 72099ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian} 72199ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian 72299ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopianstatus_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg, 723c701401f8cec2e5309f8b57e2b97baced5093274Dan Stoza nsecs_t reltime, uint32_t /* flags */) { 72499ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian status_t res = mEventQueue.postMessage(msg, reltime); 72599ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian if (res == NO_ERROR) { 72699ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian msg->wait(); 72799ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian } 72899ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian return res; 72999ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian} 730edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 7314f4f0943489d9113c66ac22b58cfba8c21dfa879Mathias Agopianvoid SurfaceFlinger::run() { 7324f4f0943489d9113c66ac22b58cfba8c21dfa879Mathias Agopian do { 7334f4f0943489d9113c66ac22b58cfba8c21dfa879Mathias Agopian waitForEvent(); 7344f4f0943489d9113c66ac22b58cfba8c21dfa879Mathias Agopian } while (true); 73599ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian} 736edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 737faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennisvoid SurfaceFlinger::enableHardwareVsync() { 738faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis Mutex::Autolock _l(mHWVsyncLock); 739948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall if (!mPrimaryHWVsyncEnabled && mHWVsyncAvailable) { 740faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mPrimaryDispSync.beginResync(); 741d1700756ec9520c3fba22f9a14fd064a6e288810Jamie Gennis //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, true); 742d1700756ec9520c3fba22f9a14fd064a6e288810Jamie Gennis mEventControlThread->setVsyncEnabled(true); 743faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mPrimaryHWVsyncEnabled = true; 74443601a2dc320a271ff8c3765ff61414a07221635Andy McFadden } 745faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis} 746faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 747948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hallvoid SurfaceFlinger::resyncToHardwareVsync(bool makeAvailable) { 748faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis Mutex::Autolock _l(mHWVsyncLock); 749faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 750948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall if (makeAvailable) { 751948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall mHWVsyncAvailable = true; 752948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall } else if (!mHWVsyncAvailable) { 753948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall ALOGE("resyncToHardwareVsync called when HW vsync unavailable"); 754948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall return; 755948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall } 756948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall 757faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis const nsecs_t period = 758faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY); 759faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 760faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mPrimaryDispSync.reset(); 761faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mPrimaryDispSync.setPeriod(period); 762faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 763faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (!mPrimaryHWVsyncEnabled) { 764faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mPrimaryDispSync.beginResync(); 765d1700756ec9520c3fba22f9a14fd064a6e288810Jamie Gennis //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, true); 766d1700756ec9520c3fba22f9a14fd064a6e288810Jamie Gennis mEventControlThread->setVsyncEnabled(true); 767faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mPrimaryHWVsyncEnabled = true; 768faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 769faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis} 770faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 771948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hallvoid SurfaceFlinger::disableHardwareVsync(bool makeUnavailable) { 772faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis Mutex::Autolock _l(mHWVsyncLock); 773faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (mPrimaryHWVsyncEnabled) { 774d1700756ec9520c3fba22f9a14fd064a6e288810Jamie Gennis //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, false); 775d1700756ec9520c3fba22f9a14fd064a6e288810Jamie Gennis mEventControlThread->setVsyncEnabled(false); 776faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mPrimaryDispSync.endResync(); 777faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mPrimaryHWVsyncEnabled = false; 778faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 779948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall if (makeUnavailable) { 780948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall mHWVsyncAvailable = false; 781948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall } 782faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis} 783faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 784faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennisvoid SurfaceFlinger::onVSyncReceived(int type, nsecs_t timestamp) { 785d1700756ec9520c3fba22f9a14fd064a6e288810Jamie Gennis bool needsHwVsync = false; 786faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 787d1700756ec9520c3fba22f9a14fd064a6e288810Jamie Gennis { // Scope for the lock 788d1700756ec9520c3fba22f9a14fd064a6e288810Jamie Gennis Mutex::Autolock _l(mHWVsyncLock); 789d1700756ec9520c3fba22f9a14fd064a6e288810Jamie Gennis if (type == 0 && mPrimaryHWVsyncEnabled) { 790d1700756ec9520c3fba22f9a14fd064a6e288810Jamie Gennis needsHwVsync = mPrimaryDispSync.addResyncSample(timestamp); 791faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 792148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopian } 793d1700756ec9520c3fba22f9a14fd064a6e288810Jamie Gennis 794d1700756ec9520c3fba22f9a14fd064a6e288810Jamie Gennis if (needsHwVsync) { 795d1700756ec9520c3fba22f9a14fd064a6e288810Jamie Gennis enableHardwareVsync(); 796d1700756ec9520c3fba22f9a14fd064a6e288810Jamie Gennis } else { 797d1700756ec9520c3fba22f9a14fd064a6e288810Jamie Gennis disableHardwareVsync(false); 798d1700756ec9520c3fba22f9a14fd064a6e288810Jamie Gennis } 799148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopian} 800148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopian 801148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopianvoid SurfaceFlinger::onHotplugReceived(int type, bool connected) { 802148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopian if (mEventThread == NULL) { 803148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopian // This is a temporary workaround for b/7145521. A non-null pointer 804148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopian // does not mean EventThread has finished initializing, so this 805148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopian // is not a correct fix. 806148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopian ALOGW("WARNING: EventThread not started, ignoring hotplug"); 807148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopian return; 808148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopian } 8099e2463e71796964cfaa06bf09a880875ac3537bcMathias Agopian 8109e663de4fe1dcc872373ee530c60a375624671c3Jesse Hall if (uint32_t(type) < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) { 8119e2463e71796964cfaa06bf09a880875ac3537bcMathias Agopian Mutex::Autolock _l(mStateLock); 812692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall if (connected) { 813692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall createBuiltinDisplayLocked((DisplayDevice::DisplayType)type); 8149e2463e71796964cfaa06bf09a880875ac3537bcMathias Agopian } else { 815692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall mCurrentState.displays.removeItem(mBuiltinDisplays[type]); 816692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall mBuiltinDisplays[type].clear(); 8179e2463e71796964cfaa06bf09a880875ac3537bcMathias Agopian } 8189e2463e71796964cfaa06bf09a880875ac3537bcMathias Agopian setTransactionFlags(eDisplayTransactionNeeded); 8199e2463e71796964cfaa06bf09a880875ac3537bcMathias Agopian 8209e9689c11148521d2c16a121a0b87b062be0714cAndy McFadden // Defer EventThread notification until SF has updated mDisplays. 8213ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias Agopian } 8228630320433bd15aca239522e54e711ef6372ab07Mathias Agopian} 8238630320433bd15aca239522e54e711ef6372ab07Mathias Agopian 82481cd5d3b94d21253a0be925f4ae58cc7f4afeef7Mathias Agopianvoid SurfaceFlinger::eventControl(int disp, int event, int enabled) { 825faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis ATRACE_CALL(); 82681cd5d3b94d21253a0be925f4ae58cc7f4afeef7Mathias Agopian getHwComposer().eventControl(disp, event, enabled); 8278630320433bd15aca239522e54e711ef6372ab07Mathias Agopian} 8288630320433bd15aca239522e54e711ef6372ab07Mathias Agopian 8294fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopianvoid SurfaceFlinger::onMessageReceived(int32_t what) { 8301c8e95cf86f2182986385bc1ee85f13f425f3a3aJamie Gennis ATRACE_CALL(); 83199ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian switch (what) { 8329eb1f0558b5fc78920602afe7bcfa3115bb1f6beMathias Agopian case MessageQueue::TRANSACTION: 8339eb1f0558b5fc78920602afe7bcfa3115bb1f6beMathias Agopian handleMessageTransaction(); 8349eb1f0558b5fc78920602afe7bcfa3115bb1f6beMathias Agopian break; 8354fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian case MessageQueue::INVALIDATE: 8364fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian handleMessageTransaction(); 8374fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian handleMessageInvalidate(); 8384fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian signalRefresh(); 8394fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian break; 8404fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian case MessageQueue::REFRESH: 8414fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian handleMessageRefresh(); 8424fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian break; 8434fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian } 8444fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian} 845edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 8464fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopianvoid SurfaceFlinger::handleMessageTransaction() { 847e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian uint32_t transactionFlags = peekTransactionFlags(eTransactionMask); 8484fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian if (transactionFlags) { 84987baae104a3e4c2059990b01c393476065c558b0Mathias Agopian handleTransaction(transactionFlags); 8504fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian } 8514fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian} 852edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 8534fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopianvoid SurfaceFlinger::handleMessageInvalidate() { 854cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian ATRACE_CALL(); 85587baae104a3e4c2059990b01c393476065c558b0Mathias Agopian handlePageFlip(); 8564fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian} 8573a3cad30c40c8eb87671262a9fe7f0e214b6a934Mathias Agopian 8584fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopianvoid SurfaceFlinger::handleMessageRefresh() { 859cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian ATRACE_CALL(); 860cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian preComposition(); 861cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian rebuildLayerStacks(); 862cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian setUpHWComposer(); 863cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian doDebugFlashRegions(); 864cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian doComposition(); 865cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian postComposition(); 866cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian} 867cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian 868cd60f99aba9e750700a967db30b74a29145739cfMathias Agopianvoid SurfaceFlinger::doDebugFlashRegions() 869cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian{ 870cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian // is debugging enabled 871cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian if (CC_LIKELY(!mDebugRegion)) 872cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian return; 873cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian 874cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian const bool repaintEverything = mRepaintEverything; 875cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 876cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian const sp<DisplayDevice>& hw(mDisplays[dpy]); 8772c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani if (hw->isDisplayOn()) { 878cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian // transform the dirty region into this screen's coordinate space 879cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian const Region dirtyRegion(hw->getDirtyRegion(repaintEverything)); 880cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian if (!dirtyRegion.isEmpty()) { 881cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian // redraw the whole screen 882cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian doComposeSurfaces(hw, Region(hw->bounds())); 883cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian 884cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian // and draw the dirty region 885cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian const int32_t height = hw->getHeight(); 8863f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian RenderEngine& engine(getRenderEngine()); 8873f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian engine.fillRegionWithColor(dirtyRegion, height, 1, 0, 1, 1); 8883f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian 889cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian hw->compositionComplete(); 890da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian hw->swapBuffers(getHwComposer()); 891cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } 892cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } 893cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } 894cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian 895cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian postFramebuffer(); 896cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian 897cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian if (mDebugRegion > 1) { 898cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian usleep(mDebugRegion * 1000); 899cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } 900bb53b0e4b97634bc31808965f81b3ab4193d0e84Mathias Agopian 901bb53b0e4b97634bc31808965f81b3ab4193d0e84Mathias Agopian HWComposer& hwc(getHwComposer()); 902bb53b0e4b97634bc31808965f81b3ab4193d0e84Mathias Agopian if (hwc.initCheck() == NO_ERROR) { 903bb53b0e4b97634bc31808965f81b3ab4193d0e84Mathias Agopian status_t err = hwc.prepare(); 904bb53b0e4b97634bc31808965f81b3ab4193d0e84Mathias Agopian ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err)); 905bb53b0e4b97634bc31808965f81b3ab4193d0e84Mathias Agopian } 906cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian} 907cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian 908cd60f99aba9e750700a967db30b74a29145739cfMathias Agopianvoid SurfaceFlinger::preComposition() 909cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian{ 910cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian bool needExtraInvalidate = false; 9111eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const LayerVector& layers(mDrawingState.layersSortedByZ); 9121eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const size_t count = layers.size(); 913cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian for (size_t i=0 ; i<count ; i++) { 9141eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian if (layers[i]->onPreComposition()) { 915cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian needExtraInvalidate = true; 916cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } 917cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } 918cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian if (needExtraInvalidate) { 919cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian signalLayerUpdate(); 920cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } 921cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian} 922a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian 923cd60f99aba9e750700a967db30b74a29145739cfMathias Agopianvoid SurfaceFlinger::postComposition() 924cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian{ 9251eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const LayerVector& layers(mDrawingState.layersSortedByZ); 9261eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const size_t count = layers.size(); 927cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian for (size_t i=0 ; i<count ; i++) { 9281eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian layers[i]->onPostComposition(); 929cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } 9304b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis 931faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis const HWComposer& hwc = getHwComposer(); 932faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY); 933faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 934faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (presentFence->isValid()) { 935faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (mPrimaryDispSync.addPresentFence(presentFence)) { 936faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis enableHardwareVsync(); 937faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } else { 938948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall disableHardwareVsync(false); 939faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 940faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 941faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 9425167ec68fed047bf65b1eb0c6091534682135eefAndy McFadden if (kIgnorePresentFences) { 943faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis const sp<const DisplayDevice> hw(getDefaultDisplayDevice()); 9442c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani if (hw->isDisplayOn()) { 945faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis enableHardwareVsync(); 946faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 947faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 948faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 9494b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis if (mAnimCompositionPending) { 9504b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis mAnimCompositionPending = false; 9514b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis 952a9a1b006e48320f5c501473e51e6c4a5f7a17b88Jesse Hall if (presentFence->isValid()) { 9534b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis mAnimFrameTracker.setActualPresentFence(presentFence); 9544b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis } else { 9554b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis // The HWC doesn't support present fences, so use the refresh 9564b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis // timestamp instead. 9574b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY); 9584b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis mAnimFrameTracker.setActualPresentTime(presentTime); 9594b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis } 9604b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis mAnimFrameTracker.advanceFrame(); 9614b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis } 962cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian} 963cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian 964cd60f99aba9e750700a967db30b74a29145739cfMathias Agopianvoid SurfaceFlinger::rebuildLayerStacks() { 965cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian // rebuild the visible layer list per screen 96652bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian if (CC_UNLIKELY(mVisibleRegionsDirty)) { 967cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian ATRACE_CALL(); 96887baae104a3e4c2059990b01c393476065c558b0Mathias Agopian mVisibleRegionsDirty = false; 96987baae104a3e4c2059990b01c393476065c558b0Mathias Agopian invalidateHwcGeometry(); 970ce3a0a541c3dde1330551bd7a048cd9d92335c00Mathias Agopian 9711eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const LayerVector& layers(mDrawingState.layersSortedByZ); 97292a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 973ce3a0a541c3dde1330551bd7a048cd9d92335c00Mathias Agopian Region opaqueRegion; 974ce3a0a541c3dde1330551bd7a048cd9d92335c00Mathias Agopian Region dirtyRegion; 97513127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian Vector< sp<Layer> > layersSortedByZ; 9764297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian const sp<DisplayDevice>& hw(mDisplays[dpy]); 9777e7ed7f77a3963a3542bde529d2797a239e2798bMathias Agopian const Transform& tr(hw->getTransform()); 9787e7ed7f77a3963a3542bde529d2797a239e2798bMathias Agopian const Rect bounds(hw->getBounds()); 9792c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani if (hw->isDisplayOn()) { 9801eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian SurfaceFlinger::computeVisibleRegions(layers, 981ce3a0a541c3dde1330551bd7a048cd9d92335c00Mathias Agopian hw->getLayerStack(), dirtyRegion, opaqueRegion); 9827e7ed7f77a3963a3542bde529d2797a239e2798bMathias Agopian 9831eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const size_t count = layers.size(); 984ce3a0a541c3dde1330551bd7a048cd9d92335c00Mathias Agopian for (size_t i=0 ; i<count ; i++) { 9851eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const sp<Layer>& layer(layers[i]); 9861eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const Layer::State& s(layer->getDrawingState()); 987ce3a0a541c3dde1330551bd7a048cd9d92335c00Mathias Agopian if (s.layerStack == hw->getLayerStack()) { 988a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall Region drawRegion(tr.transform( 989a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall layer->visibleNonTransparentRegion)); 990a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall drawRegion.andSelf(bounds); 991a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall if (!drawRegion.isEmpty()) { 992ce3a0a541c3dde1330551bd7a048cd9d92335c00Mathias Agopian layersSortedByZ.add(layer); 993ce3a0a541c3dde1330551bd7a048cd9d92335c00Mathias Agopian } 99487baae104a3e4c2059990b01c393476065c558b0Mathias Agopian } 99587baae104a3e4c2059990b01c393476065c558b0Mathias Agopian } 9963b1d2b6b2bbfb5df46b1059ec52360974e6f1428Mathias Agopian } 9974297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian hw->setVisibleLayersSortedByZ(layersSortedByZ); 9987e7ed7f77a3963a3542bde529d2797a239e2798bMathias Agopian hw->undefinedRegion.set(bounds); 9997e7ed7f77a3963a3542bde529d2797a239e2798bMathias Agopian hw->undefinedRegion.subtractSelf(tr.transform(opaqueRegion)); 10007e7ed7f77a3963a3542bde529d2797a239e2798bMathias Agopian hw->dirtyRegion.orSelf(dirtyRegion); 10013b1d2b6b2bbfb5df46b1059ec52360974e6f1428Mathias Agopian } 10023b1d2b6b2bbfb5df46b1059ec52360974e6f1428Mathias Agopian } 1003cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian} 10043b1d2b6b2bbfb5df46b1059ec52360974e6f1428Mathias Agopian 1005cd60f99aba9e750700a967db30b74a29145739cfMathias Agopianvoid SurfaceFlinger::setUpHWComposer() { 1006028dc8f2d72bc7cd4fbe7808781443125a742f78Jesse Hall for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 1007b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall bool dirty = !mDisplays[dpy]->getDirtyRegion(false).isEmpty(); 1008b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall bool empty = mDisplays[dpy]->getVisibleLayersSortedByZ().size() == 0; 1009b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall bool wasEmpty = !mDisplays[dpy]->lastCompositionHadVisibleLayers; 1010b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall 1011b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall // If nothing has changed (!dirty), don't recompose. 1012b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall // If something changed, but we don't currently have any visible layers, 1013b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall // and didn't when we last did a composition, then skip it this time. 1014b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall // The second rule does two things: 1015b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall // - When all layers are removed from a display, we'll emit one black 1016b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall // frame, then nothing more until we get new layers. 1017b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall // - When a display is created with a private layer stack, we won't 1018b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall // emit any black frames until a layer is added to the layer stack. 1019b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall bool mustRecompose = dirty && !(empty && wasEmpty); 1020b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall 1021b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall ALOGV_IF(mDisplays[dpy]->getDisplayType() == DisplayDevice::DISPLAY_VIRTUAL, 1022b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall "dpy[%zu]: %s composition (%sdirty %sempty %swasEmpty)", dpy, 1023b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall mustRecompose ? "doing" : "skipping", 1024b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall dirty ? "+" : "-", 1025b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall empty ? "+" : "-", 1026b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall wasEmpty ? "+" : "-"); 1027b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall 10287143316af216fa92c31a60d4407b707637382da1Dan Stoza mDisplays[dpy]->beginFrame(mustRecompose); 1029b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall 1030b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall if (mustRecompose) { 1031b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall mDisplays[dpy]->lastCompositionHadVisibleLayers = !empty; 1032b7a0549c983bef103ce07eb3af5905febc6e538eJesse Hall } 1033028dc8f2d72bc7cd4fbe7808781443125a742f78Jesse Hall } 1034028dc8f2d72bc7cd4fbe7808781443125a742f78Jesse Hall 103552bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian HWComposer& hwc(getHwComposer()); 103652bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian if (hwc.initCheck() == NO_ERROR) { 103752bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian // build the h/w work list 1038a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis if (CC_UNLIKELY(mHwWorkListDirty)) { 1039a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis mHwWorkListDirty = false; 1040a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 1041a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis sp<const DisplayDevice> hw(mDisplays[dpy]); 1042a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis const int32_t id = hw->getHwcDisplayId(); 1043a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis if (id >= 0) { 104413127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const Vector< sp<Layer> >& currentLayers( 1045a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis hw->getVisibleLayersSortedByZ()); 1046a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis const size_t count = currentLayers.size(); 1047a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis if (hwc.createWorkList(id, count) == NO_ERROR) { 1048a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis HWComposer::LayerListIterator cur = hwc.begin(id); 1049a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis const HWComposer::LayerListIterator end = hwc.end(id); 1050a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) { 105113127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer(currentLayers[i]); 1052a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis layer->setGeometry(hw, *cur); 10539c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette if (mDebugDisableHWC || mDebugRegion || mDaltonize || mHasColorMatrix) { 1054a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis cur->setSkip(true); 1055a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis } 1056a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis } 1057a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis } 1058a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis } 1059a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis } 1060a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis } 1061a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis 1062a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis // set the per-frame data 106392a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 10644297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian sp<const DisplayDevice> hw(mDisplays[dpy]); 1065e60b0687c8d49871d0c8786cabe6851f7a7783b5Mathias Agopian const int32_t id = hw->getHwcDisplayId(); 1066e60b0687c8d49871d0c8786cabe6851f7a7783b5Mathias Agopian if (id >= 0) { 106713127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const Vector< sp<Layer> >& currentLayers( 1068cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian hw->getVisibleLayersSortedByZ()); 1069e60b0687c8d49871d0c8786cabe6851f7a7783b5Mathias Agopian const size_t count = currentLayers.size(); 1070a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis HWComposer::LayerListIterator cur = hwc.begin(id); 1071a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis const HWComposer::LayerListIterator end = hwc.end(id); 1072a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) { 1073a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis /* 1074a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis * update the per-frame h/w composer data for each layer 1075a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis * and build the transparent region of the FB 1076a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis */ 107713127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer(currentLayers[i]); 1078a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis layer->setPerFrameData(hw, *cur); 10791e26087493ac0e7d7dc6dea8ad85cfef08b3271fMathias Agopian } 108052bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian } 108187baae104a3e4c2059990b01c393476065c558b0Mathias Agopian } 1082a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis 108303414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews // If possible, attempt to use the cursor overlay on each display. 108403414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 108503414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews sp<const DisplayDevice> hw(mDisplays[dpy]); 108603414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews const int32_t id = hw->getHwcDisplayId(); 108703414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews if (id >= 0) { 108803414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews const Vector< sp<Layer> >& currentLayers( 108903414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews hw->getVisibleLayersSortedByZ()); 109003414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews const size_t count = currentLayers.size(); 109103414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews HWComposer::LayerListIterator cur = hwc.begin(id); 109203414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews const HWComposer::LayerListIterator end = hwc.end(id); 109303414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) { 109403414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews const sp<Layer>& layer(currentLayers[i]); 109503414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews if (layer->isPotentialCursor()) { 109603414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews cur->setIsCursorLayerHint(); 109703414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews break; 109803414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews } 109903414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews } 110003414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews } 110103414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews } 110203414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews 110352bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian status_t err = hwc.prepare(); 110452bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err)); 110538efe86d9459cf5c96a24a34cc5cbf31fdba7e19Jesse Hall 110638efe86d9459cf5c96a24a34cc5cbf31fdba7e19Jesse Hall for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 110738efe86d9459cf5c96a24a34cc5cbf31fdba7e19Jesse Hall sp<const DisplayDevice> hw(mDisplays[dpy]); 110838efe86d9459cf5c96a24a34cc5cbf31fdba7e19Jesse Hall hw->prepareFrame(hwc); 110938efe86d9459cf5c96a24a34cc5cbf31fdba7e19Jesse Hall } 111052bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian } 1111cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian} 111252bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian 1113cd60f99aba9e750700a967db30b74a29145739cfMathias Agopianvoid SurfaceFlinger::doComposition() { 1114cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian ATRACE_CALL(); 111552bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian const bool repaintEverything = android_atomic_and(0, &mRepaintEverything); 111692a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 11174297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian const sp<DisplayDevice>& hw(mDisplays[dpy]); 11182c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani if (hw->isDisplayOn()) { 1119cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian // transform the dirty region into this screen's coordinate space 1120cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian const Region dirtyRegion(hw->getDirtyRegion(repaintEverything)); 112102b95105754b1859a97e234b79f41489a4677c20Mathias Agopian 112202b95105754b1859a97e234b79f41489a4677c20Mathias Agopian // repaint the framebuffer (if needed) 112302b95105754b1859a97e234b79f41489a4677c20Mathias Agopian doDisplayComposition(hw, dirtyRegion); 112402b95105754b1859a97e234b79f41489a4677c20Mathias Agopian 1125cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian hw->dirtyRegion.clear(); 1126cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian hw->flip(hw->swapRegion); 1127cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian hw->swapRegion.clear(); 112887baae104a3e4c2059990b01c393476065c558b0Mathias Agopian } 112952bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian // inform the h/w that we're done compositing 11304297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian hw->compositionComplete(); 11314fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian } 113252bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian postFramebuffer(); 1133edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1134edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1135edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Projectvoid SurfaceFlinger::postFramebuffer() 1136edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 1137841cde55549cea7a344a1705b18d57a0c6c8ec45Mathias Agopian ATRACE_CALL(); 1138b048cef231075a5e41d224b73fe11fec62f335b1Mathias Agopian 1139a44b04163957d6086362f6f365443c4c93379031Mathias Agopian const nsecs_t now = systemTime(); 1140a44b04163957d6086362f6f365443c4c93379031Mathias Agopian mDebugInSwapBuffers = now; 1141c5c5a14c06de249d8e0445fd24699e1d9aa04549Jesse Hall 114252bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian HWComposer& hwc(getHwComposer()); 1143ef19414bd8b77a26f5751f3845be79025a8263feJesse Hall if (hwc.initCheck() == NO_ERROR) { 11442a23184e4109060ec772763e80dae2132cf9d2ebMathias Agopian if (!hwc.supportsFramebufferTarget()) { 11452a23184e4109060ec772763e80dae2132cf9d2ebMathias Agopian // EGL spec says: 11462a23184e4109060ec772763e80dae2132cf9d2ebMathias Agopian // "surface must be bound to the calling thread's current context, 11472a23184e4109060ec772763e80dae2132cf9d2ebMathias Agopian // for the current rendering API." 1148875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext); 11492a23184e4109060ec772763e80dae2132cf9d2ebMathias Agopian } 1150e60b0687c8d49871d0c8786cabe6851f7a7783b5Mathias Agopian hwc.commit(); 115152bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian } 115252bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian 11536da15f46f5f8b38e31384d641f8d3db2c3c6ea30Mathias Agopian // make the default display current because the VirtualDisplayDevice code cannot 11546da15f46f5f8b38e31384d641f8d3db2c3c6ea30Mathias Agopian // deal with dequeueBuffer() being called outside of the composition loop; however 11556da15f46f5f8b38e31384d641f8d3db2c3c6ea30Mathias Agopian // the code below can call glFlush() which is allowed (and does in some case) call 11566da15f46f5f8b38e31384d641f8d3db2c3c6ea30Mathias Agopian // dequeueBuffer(). 11576da15f46f5f8b38e31384d641f8d3db2c3c6ea30Mathias Agopian getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext); 11586da15f46f5f8b38e31384d641f8d3db2c3c6ea30Mathias Agopian 115992a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 11604297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian sp<const DisplayDevice> hw(mDisplays[dpy]); 116113127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const Vector< sp<Layer> >& currentLayers(hw->getVisibleLayersSortedByZ()); 1162da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian hw->onSwapBuffersCompleted(hwc); 116352bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian const size_t count = currentLayers.size(); 1164e60b0687c8d49871d0c8786cabe6851f7a7783b5Mathias Agopian int32_t id = hw->getHwcDisplayId(); 1165e60b0687c8d49871d0c8786cabe6851f7a7783b5Mathias Agopian if (id >=0 && hwc.initCheck() == NO_ERROR) { 11661e26087493ac0e7d7dc6dea8ad85cfef08b3271fMathias Agopian HWComposer::LayerListIterator cur = hwc.begin(id); 11671e26087493ac0e7d7dc6dea8ad85cfef08b3271fMathias Agopian const HWComposer::LayerListIterator end = hwc.end(id); 116852bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian for (size_t i = 0; cur != end && i < count; ++i, ++cur) { 1169d3ee231eddce0b69ec5e35188dbd0f4a2c3b9ac3Mathias Agopian currentLayers[i]->onLayerDisplayed(hw, &*cur); 117052bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian } 1171cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } else { 117252bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian for (size_t i = 0; i < count; i++) { 1173d3ee231eddce0b69ec5e35188dbd0f4a2c3b9ac3Mathias Agopian currentLayers[i]->onLayerDisplayed(hw, NULL); 117452bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian } 1175ef19414bd8b77a26f5751f3845be79025a8263feJesse Hall } 1176e8696a40e09b24b634214684d18526187b316a2fJamie Gennis } 1177e8696a40e09b24b634214684d18526187b316a2fJamie Gennis 1178a44b04163957d6086362f6f365443c4c93379031Mathias Agopian mLastSwapBufferTime = systemTime() - now; 1179a44b04163957d6086362f6f365443c4c93379031Mathias Agopian mDebugInSwapBuffers = 0; 11806547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis 11816547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis uint32_t flipCount = getDefaultDisplayDevice()->getPageFlipCount(); 11826547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis if (flipCount % LOG_FRAME_STATS_PERIOD == 0) { 11836547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis logFrameStats(); 11846547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis } 1185edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1186edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 118787baae104a3e4c2059990b01c393476065c558b0Mathias Agopianvoid SurfaceFlinger::handleTransaction(uint32_t transactionFlags) 1188edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 1189841cde55549cea7a344a1705b18d57a0c6c8ec45Mathias Agopian ATRACE_CALL(); 1190841cde55549cea7a344a1705b18d57a0c6c8ec45Mathias Agopian 11917cc6df59572582652078df5aeac9e6c67d7fa81eMathias Agopian // here we keep a copy of the drawing state (that is the state that's 11927cc6df59572582652078df5aeac9e6c67d7fa81eMathias Agopian // going to be overwritten by handleTransactionLocked()) outside of 11937cc6df59572582652078df5aeac9e6c67d7fa81eMathias Agopian // mStateLock so that the side-effects of the State assignment 11947cc6df59572582652078df5aeac9e6c67d7fa81eMathias Agopian // don't happen with mStateLock held (which can cause deadlocks). 11957cc6df59572582652078df5aeac9e6c67d7fa81eMathias Agopian State drawingState(mDrawingState); 11967cc6df59572582652078df5aeac9e6c67d7fa81eMathias Agopian 1197ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian Mutex::Autolock _l(mStateLock); 1198ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian const nsecs_t now = systemTime(); 1199ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian mDebugInTransaction = now; 1200ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian 1201ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian // Here we're guaranteed that some transaction flags are set 1202ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian // so we can call handleTransactionLocked() unconditionally. 1203ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian // We call getTransactionFlags(), which will also clear the flags, 1204ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian // with mStateLock held to guarantee that mCurrentState won't change 1205ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian // until the transaction is committed. 1206ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian 1207e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian transactionFlags = getTransactionFlags(eTransactionMask); 120887baae104a3e4c2059990b01c393476065c558b0Mathias Agopian handleTransactionLocked(transactionFlags); 1209ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian 1210ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian mLastTransactionTime = systemTime() - now; 1211ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian mDebugInTransaction = 0; 1212ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian invalidateHwcGeometry(); 1213ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian // here the transaction has been committed 12143d57964a81cd631d80aa9575647e1ce35b5e82d5Mathias Agopian} 1215edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 121687baae104a3e4c2059990b01c393476065c558b0Mathias Agopianvoid SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags) 12173d57964a81cd631d80aa9575647e1ce35b5e82d5Mathias Agopian{ 12183d57964a81cd631d80aa9575647e1ce35b5e82d5Mathias Agopian const LayerVector& currentLayers(mCurrentState.layersSortedByZ); 1219edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project const size_t count = currentLayers.size(); 1220edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1221edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project /* 1222edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project * Traversal of the children 1223edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project * (perform the transaction for each of them if needed) 1224edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project */ 1225edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 12263559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian if (transactionFlags & eTraversalNeeded) { 1227edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project for (size_t i=0 ; i<count ; i++) { 122813127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer(currentLayers[i]); 1229edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded); 1230edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project if (!trFlags) continue; 1231edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1232edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project const uint32_t flags = layer->doTransaction(0); 1233edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project if (flags & Layer::eVisibleRegion) 1234edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project mVisibleRegionsDirty = true; 1235edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1236edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1237edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1238edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project /* 12393559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian * Perform display own transactions if needed 1240edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project */ 1241edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1242e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (transactionFlags & eDisplayTransactionNeeded) { 124392a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // here we take advantage of Vector's copy-on-write semantics to 124492a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // improve performance by skipping the transaction entirely when 124592a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // know that the lists are identical 1246e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian const KeyedVector< wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays); 1247e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian const KeyedVector< wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays); 124892a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian if (!curr.isIdenticalTo(draw)) { 1249edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project mVisibleRegionsDirty = true; 125092a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian const size_t cc = curr.size(); 125193997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian size_t dc = draw.size(); 125292a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian 125392a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // find the displays that were removed 125492a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // (ie: in drawing state but not in current state) 125592a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // also handle displays that changed 125692a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // (ie: displays that are in both lists) 125792a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian for (size_t i=0 ; i<dc ; i++) { 1258e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian const ssize_t j = curr.indexOfKey(draw.keyAt(i)); 1259e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (j < 0) { 126092a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // in drawing state but not in current state 12613ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias Agopian if (!draw[i].isMainDisplay()) { 126227ec5739bc05330e08b02f25b62a8f597bad897aAndy McFadden // Call makeCurrent() on the primary display so we can 126327ec5739bc05330e08b02f25b62a8f597bad897aAndy McFadden // be sure that nothing associated with this display 126427ec5739bc05330e08b02f25b62a8f597bad897aAndy McFadden // is current. 126502d86567d95b99e1142941ed7ec23a4465822813Jesse Hall const sp<const DisplayDevice> defaultDisplay(getDefaultDisplayDevice()); 1266875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian defaultDisplay->makeCurrent(mEGLDisplay, mEGLContext); 126702d86567d95b99e1142941ed7ec23a4465822813Jesse Hall sp<DisplayDevice> hw(getDisplayDevice(draw.keyAt(i))); 126802d86567d95b99e1142941ed7ec23a4465822813Jesse Hall if (hw != NULL) 126902d86567d95b99e1142941ed7ec23a4465822813Jesse Hall hw->disconnect(getHwComposer()); 12709e663de4fe1dcc872373ee530c60a375624671c3Jesse Hall if (draw[i].type < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) 12717adb0f8a9fdb961692ffd2f0c65cacb155143f64Jesse Hall mEventThread->onHotplugReceived(draw[i].type, false); 127202d86567d95b99e1142941ed7ec23a4465822813Jesse Hall mDisplays.removeItem(draw.keyAt(i)); 127392a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } else { 127492a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian ALOGW("trying to remove the main display"); 127592a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } 127692a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } else { 127792a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // this display is in both lists. see if something changed. 1278e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian const DisplayDeviceState& state(curr[j]); 12793ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias Agopian const wp<IBinder>& display(curr.keyAt(j)); 1280097ca275f4717a2c47a5d49f302ed2b72c8a1370Marco Nelissen const sp<IBinder> state_binder = IInterface::asBinder(state.surface); 1281097ca275f4717a2c47a5d49f302ed2b72c8a1370Marco Nelissen const sp<IBinder> draw_binder = IInterface::asBinder(draw[i].surface); 12821474f8864faafebc92ff79959bb5c698bd29b704Dan Albert if (state_binder != draw_binder) { 1283e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian // changing the surface is like destroying and 128493997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian // recreating the DisplayDevice, so we just remove it 128593997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian // from the drawing state, so that it get re-added 128693997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian // below. 128702d86567d95b99e1142941ed7ec23a4465822813Jesse Hall sp<DisplayDevice> hw(getDisplayDevice(display)); 128802d86567d95b99e1142941ed7ec23a4465822813Jesse Hall if (hw != NULL) 128902d86567d95b99e1142941ed7ec23a4465822813Jesse Hall hw->disconnect(getHwComposer()); 129093997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian mDisplays.removeItem(display); 129193997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian mDrawingState.displays.removeItemsAt(i); 129293997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian dc--; i--; 129393997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian // at this point we must loop to the next item 129493997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian continue; 129592a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } 129693997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian 1297db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian const sp<DisplayDevice> disp(getDisplayDevice(display)); 129893997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian if (disp != NULL) { 129993997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian if (state.layerStack != draw[i].layerStack) { 130093997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian disp->setLayerStack(state.layerStack); 130193997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian } 130200e8c7a88a5b9c4104a71013a713acd3e4d3b77bMathias Agopian if ((state.orientation != draw[i].orientation) 130300e8c7a88a5b9c4104a71013a713acd3e4d3b77bMathias Agopian || (state.viewport != draw[i].viewport) 130400e8c7a88a5b9c4104a71013a713acd3e4d3b77bMathias Agopian || (state.frame != draw[i].frame)) 130500e8c7a88a5b9c4104a71013a713acd3e4d3b77bMathias Agopian { 130600e8c7a88a5b9c4104a71013a713acd3e4d3b77bMathias Agopian disp->setProjection(state.orientation, 13074fb3999cea652617be5125f8a42c257467bf3c77Jeff Brown state.viewport, state.frame); 130893997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian } 130947e45405d1533aa73307014f7bf371e118695cf3Michael Lentine if (state.width != draw[i].width || state.height != draw[i].height) { 131047e45405d1533aa73307014f7bf371e118695cf3Michael Lentine disp->setDisplaySize(state.width, state.height); 131147e45405d1533aa73307014f7bf371e118695cf3Michael Lentine } 131292a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } 131392a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } 131492a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } 131592a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian 131692a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // find displays that were added 131792a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // (ie: in current state but not in drawing state) 131892a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian for (size_t i=0 ; i<cc ; i++) { 1319e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (draw.indexOfKey(curr.keyAt(i)) < 0) { 1320e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian const DisplayDeviceState& state(curr[i]); 1321cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian 132299c7dbb24994df2f3e175f7b25dd2c9dd92a72f0Jesse Hall sp<DisplaySurface> dispSurface; 1323db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian sp<IGraphicBufferProducer> producer; 1324b9b088375d33a87b201cdbe18be71802e2607717Dan Stoza sp<IGraphicBufferProducer> bqProducer; 1325b9b088375d33a87b201cdbe18be71802e2607717Dan Stoza sp<IGraphicBufferConsumer> bqConsumer; 1326b9b088375d33a87b201cdbe18be71802e2607717Dan Stoza BufferQueue::createBufferQueue(&bqProducer, &bqConsumer, 1327b9b088375d33a87b201cdbe18be71802e2607717Dan Stoza new GraphicBufferAlloc()); 1328db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian 132902d86567d95b99e1142941ed7ec23a4465822813Jesse Hall int32_t hwcDisplayId = -1; 133099c7dbb24994df2f3e175f7b25dd2c9dd92a72f0Jesse Hall if (state.isVirtualDisplay()) { 133102d86567d95b99e1142941ed7ec23a4465822813Jesse Hall // Virtual displays without a surface are dormant: 133202d86567d95b99e1142941ed7ec23a4465822813Jesse Hall // they have external state (layer stack, projection, 133302d86567d95b99e1142941ed7ec23a4465822813Jesse Hall // etc.) but no internal state (i.e. a DisplayDevice). 133499c7dbb24994df2f3e175f7b25dd2c9dd92a72f0Jesse Hall if (state.surface != NULL) { 1335db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian 133602d86567d95b99e1142941ed7ec23a4465822813Jesse Hall hwcDisplayId = allocateHwcDisplayId(state.type); 1337db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian sp<VirtualDisplaySurface> vds = new VirtualDisplaySurface( 1338b9b088375d33a87b201cdbe18be71802e2607717Dan Stoza *mHwc, hwcDisplayId, state.surface, 1339b9b088375d33a87b201cdbe18be71802e2607717Dan Stoza bqProducer, bqConsumer, state.displayName); 1340db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian 1341db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian dispSurface = vds; 134247e45405d1533aa73307014f7bf371e118695cf3Michael Lentine producer = vds; 134399c7dbb24994df2f3e175f7b25dd2c9dd92a72f0Jesse Hall } 134499c7dbb24994df2f3e175f7b25dd2c9dd92a72f0Jesse Hall } else { 1345cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian ALOGE_IF(state.surface!=NULL, 1346cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian "adding a supported display, but rendering " 1347cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian "surface is provided (%p), ignoring it", 1348cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian state.surface.get()); 134902d86567d95b99e1142941ed7ec23a4465822813Jesse Hall hwcDisplayId = allocateHwcDisplayId(state.type); 1350cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian // for supported (by hwc) displays we provide our 1351cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian // own rendering surface 1352b9b088375d33a87b201cdbe18be71802e2607717Dan Stoza dispSurface = new FramebufferSurface(*mHwc, state.type, 1353b9b088375d33a87b201cdbe18be71802e2607717Dan Stoza bqConsumer); 1354b9b088375d33a87b201cdbe18be71802e2607717Dan Stoza producer = bqProducer; 1355cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian } 1356cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian 1357cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian const wp<IBinder>& display(curr.keyAt(i)); 135899c7dbb24994df2f3e175f7b25dd2c9dd92a72f0Jesse Hall if (dispSurface != NULL) { 1359cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian sp<DisplayDevice> hw = new DisplayDevice(this, 136019e872912af66c53a4350afcc333bbafaf6a2294Jesse Hall state.type, hwcDisplayId, 136119e872912af66c53a4350afcc333bbafaf6a2294Jesse Hall mHwc->getFormat(hwcDisplayId), state.isSecure, 136205f8c703d4a050669ff8f406be3a9dc2357935f7Jesse Hall display, dispSurface, producer, 136305f8c703d4a050669ff8f406be3a9dc2357935f7Jesse Hall mRenderEngine->getEGLConfig()); 1364cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian hw->setLayerStack(state.layerStack); 1365cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian hw->setProjection(state.orientation, 13664fb3999cea652617be5125f8a42c257467bf3c77Jeff Brown state.viewport, state.frame); 13678dfa92fef9759a881e96ee58d59875d35023aab9Andy McFadden hw->setDisplayName(state.displayName); 1368cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian mDisplays.add(display, hw); 13691c569c4d45f89ec05abf8f8fe3a560e68bf39a8eJesse Hall if (state.isVirtualDisplay()) { 13701c569c4d45f89ec05abf8f8fe3a560e68bf39a8eJesse Hall if (hwcDisplayId >= 0) { 13711c569c4d45f89ec05abf8f8fe3a560e68bf39a8eJesse Hall mHwc->setVirtualDisplayProperties(hwcDisplayId, 13721c569c4d45f89ec05abf8f8fe3a560e68bf39a8eJesse Hall hw->getWidth(), hw->getHeight(), 13731c569c4d45f89ec05abf8f8fe3a560e68bf39a8eJesse Hall hw->getFormat()); 13741c569c4d45f89ec05abf8f8fe3a560e68bf39a8eJesse Hall } 13751c569c4d45f89ec05abf8f8fe3a560e68bf39a8eJesse Hall } else { 13767adb0f8a9fdb961692ffd2f0c65cacb155143f64Jesse Hall mEventThread->onHotplugReceived(state.type, true); 13771c569c4d45f89ec05abf8f8fe3a560e68bf39a8eJesse Hall } 137893997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian } 137992a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } 138092a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } 1381edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 13823559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian } 1383edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 13848430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian if (transactionFlags & (eTraversalNeeded|eDisplayTransactionNeeded)) { 13858430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // The transform hint might have changed for some layers 13868430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // (either because a display has changed, or because a layer 13878430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // as changed). 13888430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // 13898430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // Walk through all the layers in currentLayers, 13908430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // and update their transform hint. 13918430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // 13928430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // If a layer is visible only on a single display, then that 13938430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // display is used to calculate the hint, otherwise we use the 13948430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // default display. 13958430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // 13968430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // NOTE: we do this here, rather than in rebuildLayerStacks() so that 13978430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // the hint is set before we acquire a buffer from the surface texture. 13988430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // 13998430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // NOTE: layer transactions have taken place already, so we use their 14008430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // drawing state. However, SurfaceFlinger's own transaction has not 14018430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // happened yet, so we must use the current state layer list 14028430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // (soon to become the drawing state list). 14038430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // 14048430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian sp<const DisplayDevice> disp; 14058430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian uint32_t currentlayerStack = 0; 14068430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian for (size_t i=0; i<count; i++) { 14078430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // NOTE: we rely on the fact that layers are sorted by 14088430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // layerStack first (so we don't have to traverse the list 14098430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // of displays for every layer). 141013127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer(currentLayers[i]); 14111eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian uint32_t layerStack = layer->getDrawingState().layerStack; 14128430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian if (i==0 || currentlayerStack != layerStack) { 14138430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian currentlayerStack = layerStack; 14148430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // figure out if this layerstack is mirrored 14158430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // (more than one display) if so, pick the default display, 14168430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // if not, pick the only display it's on. 14178430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian disp.clear(); 14188430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 14198430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian sp<const DisplayDevice> hw(mDisplays[dpy]); 14208430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian if (hw->getLayerStack() == currentlayerStack) { 14218430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian if (disp == NULL) { 14228430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian disp = hw; 14238430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian } else { 142491d25932b6651b20159a737da6140cf8a6aaaf08Chet Haase disp = NULL; 14258430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian break; 14268430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian } 14278430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian } 14288430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian } 14298430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian } 143091d25932b6651b20159a737da6140cf8a6aaaf08Chet Haase if (disp == NULL) { 143191d25932b6651b20159a737da6140cf8a6aaaf08Chet Haase // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to 143291d25932b6651b20159a737da6140cf8a6aaaf08Chet Haase // redraw after transform hint changes. See bug 8508397. 143391d25932b6651b20159a737da6140cf8a6aaaf08Chet Haase 143491d25932b6651b20159a737da6140cf8a6aaaf08Chet Haase // could be null when this layer is using a layerStack 143591d25932b6651b20159a737da6140cf8a6aaaf08Chet Haase // that is not visible on any display. Also can occur at 143691d25932b6651b20159a737da6140cf8a6aaaf08Chet Haase // screen off/on times. 143791d25932b6651b20159a737da6140cf8a6aaaf08Chet Haase disp = getDefaultDisplayDevice(); 14388430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian } 143991d25932b6651b20159a737da6140cf8a6aaaf08Chet Haase layer->updateTransformHint(disp); 14408430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian } 14418430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian } 14428430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian 14438430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian 14443559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian /* 14453559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian * Perform our own transaction if needed 14463559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian */ 1447edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 14481eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const LayerVector& layers(mDrawingState.layersSortedByZ); 14491eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian if (currentLayers.size() > layers.size()) { 14503559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian // layers have been added 14513559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian mVisibleRegionsDirty = true; 14523559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian } 14533559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian 14543559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian // some layers might have been removed, so 14553559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian // we need to update the regions they're exposing. 14563559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian if (mLayersRemoved) { 14573559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian mLayersRemoved = false; 14583559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian mVisibleRegionsDirty = true; 14591eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const size_t count = layers.size(); 14603559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian for (size_t i=0 ; i<count ; i++) { 14611eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const sp<Layer>& layer(layers[i]); 14623559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian if (currentLayers.indexOf(layer) < 0) { 14633559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian // this layer is not visible anymore 14643559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian // TODO: we could traverse the tree from front to back and 14653559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian // compute the actual visible region 14663559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian // TODO: we could cache the transformed region 14671eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const Layer::State& s(layer->getDrawingState()); 14681501d54d63c55dc4e8f4c6eeaeac35aca6660ffcMathias Agopian Region visibleReg = s.transform.transform( 14691501d54d63c55dc4e8f4c6eeaeac35aca6660ffcMathias Agopian Region(Rect(s.active.w, s.active.h))); 14701501d54d63c55dc4e8f4c6eeaeac35aca6660ffcMathias Agopian invalidateLayerStack(s.layerStack, visibleReg); 14710aa758d64ac530833ce9a311b164c9175a7a054cMathias Agopian } 1472edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1473edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1474edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1475edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project commitTransaction(); 147603414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews 147703414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews updateCursorAsync(); 147803414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews} 147903414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews 148003414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrewsvoid SurfaceFlinger::updateCursorAsync() 148103414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews{ 148203414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews HWComposer& hwc(getHwComposer()); 148303414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 148403414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews sp<const DisplayDevice> hw(mDisplays[dpy]); 148503414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews const int32_t id = hw->getHwcDisplayId(); 148603414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews if (id < 0) { 148703414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews continue; 148803414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews } 148903414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews const Vector< sp<Layer> >& currentLayers( 149003414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews hw->getVisibleLayersSortedByZ()); 149103414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews const size_t count = currentLayers.size(); 149203414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews HWComposer::LayerListIterator cur = hwc.begin(id); 149303414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews const HWComposer::LayerListIterator end = hwc.end(id); 149403414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) { 149503414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews if (cur->getCompositionType() != HWC_CURSOR_OVERLAY) { 149603414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews continue; 149703414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews } 149803414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews const sp<Layer>& layer(currentLayers[i]); 149903414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews Rect cursorPos = layer->getPosition(hw); 150003414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews hwc.setCursorPositionAsync(id, cursorPos); 150103414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews break; 150203414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews } 150303414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews } 15044fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian} 15054fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian 15064fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopianvoid SurfaceFlinger::commitTransaction() 15074fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian{ 15084fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian if (!mLayersPendingRemoval.isEmpty()) { 15094fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian // Notify removed layers now that they can't be drawn from 15104fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian for (size_t i = 0; i < mLayersPendingRemoval.size(); i++) { 15114fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian mLayersPendingRemoval[i]->onRemoved(); 15124fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian } 15134fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian mLayersPendingRemoval.clear(); 15144fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian } 15154fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian 15164b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis // If this transaction is part of a window animation then the next frame 15174b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis // we composite should be considered an animation as well. 15184b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis mAnimCompositionPending = mAnimTransactionPending; 15194b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis 15204fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian mDrawingState = mCurrentState; 15212d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis mTransactionPending = false; 15222d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis mAnimTransactionPending = false; 15234fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian mTransactionCV.broadcast(); 1524edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1525edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1526edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Projectvoid SurfaceFlinger::computeVisibleRegions( 152787baae104a3e4c2059990b01c393476065c558b0Mathias Agopian const LayerVector& currentLayers, uint32_t layerStack, 152887baae104a3e4c2059990b01c393476065c558b0Mathias Agopian Region& outDirtyRegion, Region& outOpaqueRegion) 1529edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 1530841cde55549cea7a344a1705b18d57a0c6c8ec45Mathias Agopian ATRACE_CALL(); 1531841cde55549cea7a344a1705b18d57a0c6c8ec45Mathias Agopian 1532edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project Region aboveOpaqueLayers; 1533edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project Region aboveCoveredLayers; 1534edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project Region dirty; 1535edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 153687baae104a3e4c2059990b01c393476065c558b0Mathias Agopian outDirtyRegion.clear(); 1537edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1538edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project size_t i = currentLayers.size(); 1539edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project while (i--) { 154013127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer = currentLayers[i]; 1541edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1542edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project // start with the whole surface at its current location 15431eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const Layer::State& s(layer->getDrawingState()); 1544edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 154501e29054e672301e4adbbca15b3562a59a20f267Jesse Hall // only consider the layers on the given layer stack 154687baae104a3e4c2059990b01c393476065c558b0Mathias Agopian if (s.layerStack != layerStack) 154787baae104a3e4c2059990b01c393476065c558b0Mathias Agopian continue; 154887baae104a3e4c2059990b01c393476065c558b0Mathias Agopian 1549ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian /* 1550ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * opaqueRegion: area of a surface that is fully opaque. 1551ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian */ 1552edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project Region opaqueRegion; 1553ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian 1554ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian /* 1555ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * visibleRegion: area of a surface that is visible on screen 1556ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * and not fully transparent. This is essentially the layer's 1557ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * footprint minus the opaque regions above it. 1558ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * Areas covered by a translucent surface are considered visible. 1559ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian */ 1560edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project Region visibleRegion; 1561ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian 1562ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian /* 1563ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * coveredRegion: area of a surface that is covered by all 1564ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * visible regions above it (which includes the translucent areas). 1565ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian */ 1566edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project Region coveredRegion; 1567ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian 1568a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall /* 1569a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall * transparentRegion: area of a surface that is hinted to be completely 1570a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall * transparent. This is only used to tell when the layer has no visible 1571a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall * non-transparent regions and can be removed from the layer list. It 1572a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall * does not affect the visibleRegion of this layer or any layers 1573a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall * beneath it. The hint may not be correct if apps don't respect the 1574a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall * SurfaceView restrictions (which, sadly, some don't). 1575a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall */ 1576a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall Region transparentRegion; 1577a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall 1578ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian 1579ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian // handle hidden surfaces by setting the visible region to empty 1580da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian if (CC_LIKELY(layer->isVisible())) { 15814125a4ffaf374ca9c0773f256998557d3325343eAndy McFadden const bool translucent = !layer->isOpaque(s); 15825219a06d61ac4517506500363c5e8a5972dd7ac9Mathias Agopian Rect bounds(s.transform.transform(layer->computeBounds())); 1583edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project visibleRegion.set(bounds); 1584ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian if (!visibleRegion.isEmpty()) { 1585ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian // Remove the transparent area from the visible region 1586ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian if (translucent) { 15874fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian const Transform tr(s.transform); 15884fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian if (tr.transformed()) { 15894fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian if (tr.preserveRects()) { 15904fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian // transform the transparent region 15912ca79399b933935eb1b6c0ec1f746f8c4475369cMathias Agopian transparentRegion = tr.transform(s.activeTransparentRegion); 15924fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian } else { 15934fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian // transformation too complex, can't do the 15944fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian // transparent region optimization. 1595a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall transparentRegion.clear(); 15964fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian } 15974fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian } else { 15982ca79399b933935eb1b6c0ec1f746f8c4475369cMathias Agopian transparentRegion = s.activeTransparentRegion; 15994fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian } 1600ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian } 1601edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1602ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian // compute the opaque region 16034fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian const int32_t layerOrientation = s.transform.getOrientation(); 1604ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian if (s.alpha==255 && !translucent && 1605ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian ((layerOrientation & Transform::ROT_INVALID) == false)) { 1606ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian // the opaque region is the layer's footprint 1607ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian opaqueRegion = visibleRegion; 1608ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian } 1609edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1610edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1611edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1612ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian // Clip the covered region to the visible region 1613ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian coveredRegion = aboveCoveredLayers.intersect(visibleRegion); 1614ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian 1615ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian // Update aboveCoveredLayers for next (lower) layer 1616ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian aboveCoveredLayers.orSelf(visibleRegion); 1617ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian 1618edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project // subtract the opaque region covered by the layers above us 1619edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project visibleRegion.subtractSelf(aboveOpaqueLayers); 1620edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1621edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project // compute this layer's dirty region 1622edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project if (layer->contentDirty) { 1623edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project // we need to invalidate the whole region 1624edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project dirty = visibleRegion; 1625edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project // as well, as the old visible region 16264fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian dirty.orSelf(layer->visibleRegion); 1627edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project layer->contentDirty = false; 1628edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } else { 1629a8d44f75e1934072713371a2dcd143c63ffcbe0eMathias Agopian /* compute the exposed region: 1630ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * the exposed region consists of two components: 1631ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * 1) what's VISIBLE now and was COVERED before 1632ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * 2) what's EXPOSED now less what was EXPOSED before 1633ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * 1634ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * note that (1) is conservative, we start with the whole 1635ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * visible region but only keep what used to be covered by 1636ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * something -- which mean it may have been exposed. 1637ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * 1638ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * (2) handles areas that were not covered by anything but got 1639ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * exposed because of a resize. 1640a8d44f75e1934072713371a2dcd143c63ffcbe0eMathias Agopian */ 1641ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian const Region newExposed = visibleRegion - coveredRegion; 16424fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian const Region oldVisibleRegion = layer->visibleRegion; 16434fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian const Region oldCoveredRegion = layer->coveredRegion; 1644ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian const Region oldExposed = oldVisibleRegion - oldCoveredRegion; 1645ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian dirty = (visibleRegion&oldCoveredRegion) | (newExposed-oldExposed); 1646edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1647edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project dirty.subtractSelf(aboveOpaqueLayers); 1648edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1649edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project // accumulate to the screen dirty region 165087baae104a3e4c2059990b01c393476065c558b0Mathias Agopian outDirtyRegion.orSelf(dirty); 1651edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1652ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian // Update aboveOpaqueLayers for next (lower) layer 1653edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project aboveOpaqueLayers.orSelf(opaqueRegion); 16548b42e8a5d87dcdc8ea31368ab88de49b72ab5432Andreas Huber 1655a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall // Store the visible region in screen space 1656edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project layer->setVisibleRegion(visibleRegion); 1657edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project layer->setCoveredRegion(coveredRegion); 1658a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall layer->setVisibleNonTransparentRegion( 1659a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall visibleRegion.subtract(transparentRegion)); 1660edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1661edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 166287baae104a3e4c2059990b01c393476065c558b0Mathias Agopian outOpaqueRegion = aboveOpaqueLayers; 1663edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1664edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 166587baae104a3e4c2059990b01c393476065c558b0Mathias Agopianvoid SurfaceFlinger::invalidateLayerStack(uint32_t layerStack, 166687baae104a3e4c2059990b01c393476065c558b0Mathias Agopian const Region& dirty) { 166792a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 16684297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian const sp<DisplayDevice>& hw(mDisplays[dpy]); 16694297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian if (hw->getLayerStack() == layerStack) { 16704297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian hw->dirtyRegion.orSelf(dirty); 167192a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } 167292a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } 167387baae104a3e4c2059990b01c393476065c558b0Mathias Agopian} 167487baae104a3e4c2059990b01c393476065c558b0Mathias Agopian 167587baae104a3e4c2059990b01c393476065c558b0Mathias Agopianvoid SurfaceFlinger::handlePageFlip() 1676edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 16774fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian Region dirtyRegion; 167899ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian 16794fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian bool visibleRegions = false; 16801eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const LayerVector& layers(mDrawingState.layersSortedByZ); 168151c59cd1e73be3787eb75bebd87fc41739c65adbEric Penner 168251c59cd1e73be3787eb75bebd87fc41739c65adbEric Penner // Store the set of layers that need updates. This set must not change as 168351c59cd1e73be3787eb75bebd87fc41739c65adbEric Penner // buffers are being latched, as this could result in a deadlock. 168451c59cd1e73be3787eb75bebd87fc41739c65adbEric Penner // Example: Two producers share the same command stream and: 168551c59cd1e73be3787eb75bebd87fc41739c65adbEric Penner // 1.) Layer 0 is latched 168651c59cd1e73be3787eb75bebd87fc41739c65adbEric Penner // 2.) Layer 0 gets a new frame 168751c59cd1e73be3787eb75bebd87fc41739c65adbEric Penner // 2.) Layer 1 gets a new frame 168851c59cd1e73be3787eb75bebd87fc41739c65adbEric Penner // 3.) Layer 1 is latched. 168951c59cd1e73be3787eb75bebd87fc41739c65adbEric Penner // Display is now waiting on Layer 1's frame, which is behind layer 0's 169051c59cd1e73be3787eb75bebd87fc41739c65adbEric Penner // second frame. But layer 0's second frame could be waiting on display. 169151c59cd1e73be3787eb75bebd87fc41739c65adbEric Penner Vector<Layer*> layersWithQueuedFrames; 169251c59cd1e73be3787eb75bebd87fc41739c65adbEric Penner for (size_t i = 0, count = layers.size(); i<count ; i++) { 16931eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const sp<Layer>& layer(layers[i]); 169451c59cd1e73be3787eb75bebd87fc41739c65adbEric Penner if (layer->hasQueuedFrame()) 169551c59cd1e73be3787eb75bebd87fc41739c65adbEric Penner layersWithQueuedFrames.push_back(layer.get()); 169651c59cd1e73be3787eb75bebd87fc41739c65adbEric Penner } 169751c59cd1e73be3787eb75bebd87fc41739c65adbEric Penner for (size_t i = 0, count = layersWithQueuedFrames.size() ; i<count ; i++) { 169851c59cd1e73be3787eb75bebd87fc41739c65adbEric Penner Layer* layer = layersWithQueuedFrames[i]; 169987baae104a3e4c2059990b01c393476065c558b0Mathias Agopian const Region dirty(layer->latchBuffer(visibleRegions)); 17001eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const Layer::State& s(layer->getDrawingState()); 170187baae104a3e4c2059990b01c393476065c558b0Mathias Agopian invalidateLayerStack(s.layerStack, dirty); 17024fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian } 17034da751999358fffa4cefc4c8046dab72045925f6Mathias Agopian 17043b1d2b6b2bbfb5df46b1059ec52360974e6f1428Mathias Agopian mVisibleRegionsDirty |= visibleRegions; 1705edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1706edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1707ad456f9878ff7c176499e7b992f9ff1cb3e9cdeeMathias Agopianvoid SurfaceFlinger::invalidateHwcGeometry() 1708ad456f9878ff7c176499e7b992f9ff1cb3e9cdeeMathias Agopian{ 1709ad456f9878ff7c176499e7b992f9ff1cb3e9cdeeMathias Agopian mHwWorkListDirty = true; 1710ad456f9878ff7c176499e7b992f9ff1cb3e9cdeeMathias Agopian} 1711ad456f9878ff7c176499e7b992f9ff1cb3e9cdeeMathias Agopian 171299ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian 1713cd60f99aba9e750700a967db30b74a29145739cfMathias Agopianvoid SurfaceFlinger::doDisplayComposition(const sp<const DisplayDevice>& hw, 171487baae104a3e4c2059990b01c393476065c558b0Mathias Agopian const Region& inDirtyRegion) 1715edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 17167143316af216fa92c31a60d4407b707637382da1Dan Stoza // We only need to actually compose the display if: 17177143316af216fa92c31a60d4407b707637382da1Dan Stoza // 1) It is being handled by hardware composer, which may need this to 17187143316af216fa92c31a60d4407b707637382da1Dan Stoza // keep its virtual display state machine in sync, or 17197143316af216fa92c31a60d4407b707637382da1Dan Stoza // 2) There is work to be done (the dirty region isn't empty) 17207143316af216fa92c31a60d4407b707637382da1Dan Stoza bool isHwcDisplay = hw->getHwcDisplayId() >= 0; 17217143316af216fa92c31a60d4407b707637382da1Dan Stoza if (!isHwcDisplay && inDirtyRegion.isEmpty()) { 17227143316af216fa92c31a60d4407b707637382da1Dan Stoza return; 17237143316af216fa92c31a60d4407b707637382da1Dan Stoza } 17247143316af216fa92c31a60d4407b707637382da1Dan Stoza 172587baae104a3e4c2059990b01c393476065c558b0Mathias Agopian Region dirtyRegion(inDirtyRegion); 172687baae104a3e4c2059990b01c393476065c558b0Mathias Agopian 1727b8a5560e1303cb10f5cd482af466fc04d2bdfcabMathias Agopian // compute the invalid region 17284297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian hw->swapRegion.orSelf(dirtyRegion); 1729edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 17304297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian uint32_t flags = hw->getFlags(); 17310f2f5ff75b7b48ceb64270655ee6b62d09bf4d00Mathias Agopian if (flags & DisplayDevice::SWAP_RECTANGLE) { 173229d06ac9a45e564b4f935b91067fc92c2d4c193dMathias Agopian // we can redraw only what's dirty, but since SWAP_RECTANGLE only 173329d06ac9a45e564b4f935b91067fc92c2d4c193dMathias Agopian // takes a rectangle, we must make sure to update that whole 173429d06ac9a45e564b4f935b91067fc92c2d4c193dMathias Agopian // rectangle in that case 17354297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian dirtyRegion.set(hw->swapRegion.bounds()); 1736edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } else { 17370f2f5ff75b7b48ceb64270655ee6b62d09bf4d00Mathias Agopian if (flags & DisplayDevice::PARTIAL_UPDATES) { 173829d06ac9a45e564b4f935b91067fc92c2d4c193dMathias Agopian // We need to redraw the rectangle that will be updated 1739df3ca30bf663cb8eed88ee3f16fb5e9a65dc00fcMathias Agopian // (pushed to the framebuffer). 174095a666b0e001ebf738418b89d8e8fd50b18110f8Mathias Agopian // This is needed because PARTIAL_UPDATES only takes one 17410f2f5ff75b7b48ceb64270655ee6b62d09bf4d00Mathias Agopian // rectangle instead of a region (see DisplayDevice::flip()) 17424297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian dirtyRegion.set(hw->swapRegion.bounds()); 1743edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } else { 174429d06ac9a45e564b4f935b91067fc92c2d4c193dMathias Agopian // we need to redraw everything (the whole screen) 17454297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian dirtyRegion.set(hw->bounds()); 17464297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian hw->swapRegion = dirtyRegion; 1747edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1748edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1749edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 17509c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette if (CC_LIKELY(!mDaltonize && !mHasColorMatrix)) { 17513f121fc650d72d0103cef8e6a651093fb1589e0aMichael Lentine if (!doComposeSurfaces(hw, dirtyRegion)) return; 1752ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian } else { 1753ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian RenderEngine& engine(getRenderEngine()); 17549c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette mat4 colorMatrix = mColorMatrix; 17559c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette if (mDaltonize) { 17569c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette colorMatrix = colorMatrix * mDaltonizer(); 17579c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette } 17589c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette engine.beginGroup(colorMatrix); 1759ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian doComposeSurfaces(hw, dirtyRegion); 1760ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian engine.endGroup(); 1761ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian } 1762edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 17639c6e297271ec9af9d974242d89cfa08cb6ceaa0aMathias Agopian // update the swap region and clear the dirty region 17644297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian hw->swapRegion.orSelf(dirtyRegion); 1765da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian 1766da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian // swap buffers (presentation) 1767da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian hw->swapBuffers(getHwComposer()); 1768edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1769edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 17703f121fc650d72d0103cef8e6a651093fb1589e0aMichael Lentinebool SurfaceFlinger::doComposeSurfaces(const sp<const DisplayDevice>& hw, const Region& dirty) 1771edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 17723f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian RenderEngine& engine(getRenderEngine()); 177385d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian const int32_t id = hw->getHwcDisplayId(); 17748630320433bd15aca239522e54e711ef6372ab07Mathias Agopian HWComposer& hwc(getHwComposer()); 17751e26087493ac0e7d7dc6dea8ad85cfef08b3271fMathias Agopian HWComposer::LayerListIterator cur = hwc.begin(id); 17761e26087493ac0e7d7dc6dea8ad85cfef08b3271fMathias Agopian const HWComposer::LayerListIterator end = hwc.end(id); 1777a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian 1778d05a17fbb3772051d287f1f8830a7f00964f7ec2Jesse Hall bool hasGlesComposition = hwc.hasGlesComposition(id); 177985d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian if (hasGlesComposition) { 1780875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian if (!hw->makeCurrent(mEGLDisplay, mEGLContext)) { 1781c8c71096195de0128e57574b1ddf685838ceb2f0Michael Chock ALOGW("DisplayDevice::makeCurrent failed. Aborting surface composition for display %s", 1782c8c71096195de0128e57574b1ddf685838ceb2f0Michael Chock hw->getDisplayName().string()); 17833f121fc650d72d0103cef8e6a651093fb1589e0aMichael Lentine eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); 17843f121fc650d72d0103cef8e6a651093fb1589e0aMichael Lentine if(!getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext)) { 17853f121fc650d72d0103cef8e6a651093fb1589e0aMichael Lentine ALOGE("DisplayDevice::makeCurrent on default display failed. Aborting."); 17863f121fc650d72d0103cef8e6a651093fb1589e0aMichael Lentine } 17873f121fc650d72d0103cef8e6a651093fb1589e0aMichael Lentine return false; 1788c8c71096195de0128e57574b1ddf685838ceb2f0Michael Chock } 1789a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian 1790a2f4e56fec0fb36c4a370eb23d6e9dc57f250b59Mathias Agopian // Never touch the framebuffer if we don't have any framebuffer layers 179185d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian const bool hasHwcComposition = hwc.hasHwcComposition(id); 1792e60b0687c8d49871d0c8786cabe6851f7a7783b5Mathias Agopian if (hasHwcComposition) { 1793b9494d5c9d44e4a59b6d510fea1665de434f3c6bMathias Agopian // when using overlays, we assume a fully transparent framebuffer 1794b9494d5c9d44e4a59b6d510fea1665de434f3c6bMathias Agopian // NOTE: we could reduce how much we need to clear, for instance 1795b9494d5c9d44e4a59b6d510fea1665de434f3c6bMathias Agopian // remove where there are opaque FB layers. however, on some 17963f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian // GPUs doing a "clean slate" clear might be more efficient. 1797b9494d5c9d44e4a59b6d510fea1665de434f3c6bMathias Agopian // We'll revisit later if needed. 17983f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian engine.clearWithColor(0, 0, 0, 0); 1799b9494d5c9d44e4a59b6d510fea1665de434f3c6bMathias Agopian } else { 1800766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian // we start with the whole screen area 1801766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian const Region bounds(hw->getBounds()); 1802766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian 1803766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian // we remove the scissor part 1804766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian // we're left with the letterbox region 1805766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian // (common case is that letterbox ends-up being empty) 1806766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian const Region letterbox(bounds.subtract(hw->getScissor())); 1807766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian 1808766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian // compute the area to clear 1809766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian Region region(hw->undefinedRegion.merge(letterbox)); 1810766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian 1811766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian // but limit it to the dirty region 1812766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian region.andSelf(dirty); 1813766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian 1814b9494d5c9d44e4a59b6d510fea1665de434f3c6bMathias Agopian // screen is already cleared here 181587baae104a3e4c2059990b01c393476065c558b0Mathias Agopian if (!region.isEmpty()) { 1816b9494d5c9d44e4a59b6d510fea1665de434f3c6bMathias Agopian // can happen with SurfaceView 181755801e41e6d7306d75d8134dd69d7d8cbbfbc63cMathias Agopian drawWormhole(hw, region); 1818b9494d5c9d44e4a59b6d510fea1665de434f3c6bMathias Agopian } 1819a2f4e56fec0fb36c4a370eb23d6e9dc57f250b59Mathias Agopian } 1820f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian 1821766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian if (hw->getDisplayType() != DisplayDevice::DISPLAY_PRIMARY) { 1822766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian // just to be on the safe side, we don't set the 1823f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian // scissor on the main display. It should never be needed 1824f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian // anyways (though in theory it could since the API allows it). 1825f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian const Rect& bounds(hw->getBounds()); 1826766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian const Rect& scissor(hw->getScissor()); 1827f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian if (scissor != bounds) { 1828f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian // scissor doesn't match the screen's dimensions, so we 1829f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian // need to clear everything outside of it and enable 1830f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian // the GL scissor so we don't draw anything where we shouldn't 18313f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian 1832f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian // enable scissor for this frame 18333f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian const uint32_t height = hw->getHeight(); 18343f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian engine.setScissor(scissor.left, height - scissor.bottom, 18353f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian scissor.getWidth(), scissor.getHeight()); 1836f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian } 1837f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian } 183885d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian } 18394b2ba53423ac2dc795a5a0bf72f6d787d9dc8950Mathias Agopian 184085d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian /* 184185d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian * and then, render the layers targeted at the framebuffer 184285d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian */ 18434b2ba53423ac2dc795a5a0bf72f6d787d9dc8950Mathias Agopian 184413127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const Vector< sp<Layer> >& layers(hw->getVisibleLayersSortedByZ()); 184585d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian const size_t count = layers.size(); 184685d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian const Transform& tr = hw->getTransform(); 184785d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian if (cur != end) { 184885d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian // we're using h/w composer 184985d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian for (size_t i=0 ; i<count && cur!=end ; ++i, ++cur) { 185013127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer(layers[i]); 18514fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian const Region clip(dirty.intersect(tr.transform(layer->visibleRegion))); 185285d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian if (!clip.isEmpty()) { 185385d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian switch (cur->getCompositionType()) { 185403414a1cfe6c1222fd7723949bd622f9cba145aaRiley Andrews case HWC_CURSOR_OVERLAY: 185585d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian case HWC_OVERLAY: { 1856ac68302e1cde8b931073929311fd6654a3253fc7Mathias Agopian const Layer::State& state(layer->getDrawingState()); 185785d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian if ((cur->getHints() & HWC_HINT_CLEAR_FB) 185885d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian && i 18594125a4ffaf374ca9c0773f256998557d3325343eAndy McFadden && layer->isOpaque(state) && (state.alpha == 0xFF) 186085d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian && hasGlesComposition) { 1861cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian // never clear the very first layer since we're 1862cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian // guaranteed the FB is already cleared 1863cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian layer->clearWithOpenGL(hw, clip); 1864cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } 186585d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian break; 186685d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian } 186785d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian case HWC_FRAMEBUFFER: { 1868cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian layer->draw(hw, clip); 186985d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian break; 1870a2f4e56fec0fb36c4a370eb23d6e9dc57f250b59Mathias Agopian } 1871da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian case HWC_FRAMEBUFFER_TARGET: { 1872da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian // this should not happen as the iterator shouldn't 1873da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian // let us get there. 187486efcc0cbc1d94250b72ef1f2ea8700a04cd2781Greg Hackmann ALOGW("HWC_FRAMEBUFFER_TARGET found in hwc list (index=%zu)", i); 1875da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian break; 1876da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian } 1877cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } 1878a6b32db164e7834e211261046f3229bf50bc0098Jesse Hall } 187985d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian layer->setAcquireFence(hw, *cur); 188085d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian } 188185d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian } else { 188285d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian // we're not using h/w composer 188385d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian for (size_t i=0 ; i<count ; ++i) { 188413127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer(layers[i]); 188585d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian const Region clip(dirty.intersect( 188685d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian tr.transform(layer->visibleRegion))); 188785d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian if (!clip.isEmpty()) { 188885d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian layer->draw(hw, clip); 188985d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian } 18904b2ba53423ac2dc795a5a0bf72f6d787d9dc8950Mathias Agopian } 18914b2ba53423ac2dc795a5a0bf72f6d787d9dc8950Mathias Agopian } 1892f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian 1893f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian // disable scissor at the end of the frame 18943f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian engine.disableScissor(); 18953f121fc650d72d0103cef8e6a651093fb1589e0aMichael Lentine return true; 1896edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1897edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 18983f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopianvoid SurfaceFlinger::drawWormhole(const sp<const DisplayDevice>& hw, const Region& region) const { 189955801e41e6d7306d75d8134dd69d7d8cbbfbc63cMathias Agopian const int32_t height = hw->getHeight(); 19003f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian RenderEngine& engine(getRenderEngine()); 19013f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian engine.fillRegionWithColor(region, height, 0, 0, 0, 0); 1902edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1903edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1904ac9fa427d4a86745e60a5f7fd8e3ea340c4db907Mathias Agopianvoid SurfaceFlinger::addClientLayer(const sp<Client>& client, 1905ac9fa427d4a86745e60a5f7fd8e3ea340c4db907Mathias Agopian const sp<IBinder>& handle, 19066710604286401d4205c27235a252dd0e5008cc08Mathias Agopian const sp<IGraphicBufferProducer>& gbc, 190713127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& lbc) 19081b5e1021b8c9b87113b70d94dfb7b50f8c5b01b8Mathias Agopian{ 190996f0819f81293076e652792794a961543e6750d7Mathias Agopian // attach this layer to the client 1910ac9fa427d4a86745e60a5f7fd8e3ea340c4db907Mathias Agopian client->attachLayer(handle, lbc); 19114f113740180b6512b43723c4728f262882dc9b45Mathias Agopian 191296f0819f81293076e652792794a961543e6750d7Mathias Agopian // add this layer to the current state list 1913921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian Mutex::Autolock _l(mStateLock); 1914921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian mCurrentState.layersSortedByZ.add(lbc); 1915097ca275f4717a2c47a5d49f302ed2b72c8a1370Marco Nelissen mGraphicBufferProducerList.add(IInterface::asBinder(gbc)); 191696f0819f81293076e652792794a961543e6750d7Mathias Agopian} 191796f0819f81293076e652792794a961543e6750d7Mathias Agopian 19183f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopianstatus_t SurfaceFlinger::removeLayer(const sp<Layer>& layer) { 191996f0819f81293076e652792794a961543e6750d7Mathias Agopian Mutex::Autolock _l(mStateLock); 192013127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian ssize_t index = mCurrentState.layersSortedByZ.remove(layer); 1921edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project if (index >= 0) { 19226710604286401d4205c27235a252dd0e5008cc08Mathias Agopian mLayersPendingRemoval.push(layer); 1923076b1cc3a9b90aa5b381a1ed268ca0b548444c9bMathias Agopian mLayersRemoved = true; 19246710604286401d4205c27235a252dd0e5008cc08Mathias Agopian setTransactionFlags(eTransactionNeeded); 1925edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project return NO_ERROR; 1926edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 19273d57964a81cd631d80aa9575647e1ce35b5e82d5Mathias Agopian return status_t(index); 1928edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1929edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1930c701401f8cec2e5309f8b57e2b97baced5093274Dan Stozauint32_t SurfaceFlinger::peekTransactionFlags(uint32_t /* flags */) { 1931dea20b1f343012d58ca9eb381684b26a168dc127Mathias Agopian return android_atomic_release_load(&mTransactionFlags); 1932dea20b1f343012d58ca9eb381684b26a168dc127Mathias Agopian} 1933dea20b1f343012d58ca9eb381684b26a168dc127Mathias Agopian 19343f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopianuint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags) { 1935edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project return android_atomic_and(~flags, &mTransactionFlags) & flags; 1936edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1937edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 19383f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopianuint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags) { 1939edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project uint32_t old = android_atomic_or(flags, &mTransactionFlags); 1940edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project if ((old & flags)==0) { // wake the server up 194199ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian signalTransaction(); 1942edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1943edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project return old; 1944edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1945edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 19468b33f032327f8de0dcc0e6d0d43ed80f834b51f6Mathias Agopianvoid SurfaceFlinger::setTransactionState( 19478b33f032327f8de0dcc0e6d0d43ed80f834b51f6Mathias Agopian const Vector<ComposerState>& state, 19488b33f032327f8de0dcc0e6d0d43ed80f834b51f6Mathias Agopian const Vector<DisplayState>& displays, 19498b33f032327f8de0dcc0e6d0d43ed80f834b51f6Mathias Agopian uint32_t flags) 19508b33f032327f8de0dcc0e6d0d43ed80f834b51f6Mathias Agopian{ 19517c41bf7092b75dba6029cd3bbc842d3a2661b0aaJamie Gennis ATRACE_CALL(); 1952698c0873cf2e07bdc7fd1e72169aee2a19fa40d7Mathias Agopian Mutex::Autolock _l(mStateLock); 195328378392fd5aa3e0a392c9eb64634055678c3987Jamie Gennis uint32_t transactionFlags = 0; 1954e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian 19552d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis if (flags & eAnimation) { 19562d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis // For window updates that are part of an animation we must wait for 19572d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis // previous animation "frames" to be handled. 19582d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis while (mAnimTransactionPending) { 19597c41bf7092b75dba6029cd3bbc842d3a2661b0aaJamie Gennis status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5)); 19602d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis if (CC_UNLIKELY(err != NO_ERROR)) { 19612d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis // just in case something goes wrong in SF, return to the 19627c41bf7092b75dba6029cd3bbc842d3a2661b0aaJamie Gennis // caller after a few seconds. 19637c41bf7092b75dba6029cd3bbc842d3a2661b0aaJamie Gennis ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out " 19647c41bf7092b75dba6029cd3bbc842d3a2661b0aaJamie Gennis "waiting for previous animation frame"); 19652d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis mAnimTransactionPending = false; 19662d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis break; 19672d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis } 19682d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis } 19692d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis } 19702d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis 1971e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian size_t count = displays.size(); 1972e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian for (size_t i=0 ; i<count ; i++) { 1973e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian const DisplayState& s(displays[i]); 1974e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian transactionFlags |= setDisplayStateLocked(s); 1975b8d69a55f1c187a35ac41e69de63251f5501b6f4Jamie Gennis } 1976b8d69a55f1c187a35ac41e69de63251f5501b6f4Jamie Gennis 1977e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian count = state.size(); 1978698c0873cf2e07bdc7fd1e72169aee2a19fa40d7Mathias Agopian for (size_t i=0 ; i<count ; i++) { 1979698c0873cf2e07bdc7fd1e72169aee2a19fa40d7Mathias Agopian const ComposerState& s(state[i]); 1980d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian // Here we need to check that the interface we're given is indeed 1981d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian // one of our own. A malicious client could give us a NULL 1982d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian // IInterface, or one of its own or even one of our own but a 1983d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian // different type. All these situations would cause us to crash. 1984d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian // 1985d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian // NOTE: it would be better to use RTTI as we could directly check 1986d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian // that we have a Client*. however, RTTI is disabled in Android. 1987d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian if (s.client != NULL) { 1988097ca275f4717a2c47a5d49f302ed2b72c8a1370Marco Nelissen sp<IBinder> binder = IInterface::asBinder(s.client); 1989d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian if (binder != NULL) { 1990d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian String16 desc(binder->getInterfaceDescriptor()); 1991d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian if (desc == ISurfaceComposerClient::descriptor) { 1992d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian sp<Client> client( static_cast<Client *>(s.client.get()) ); 1993d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian transactionFlags |= setClientStateLocked(client, s.state); 1994d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian } 1995d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian } 1996d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian } 1997698c0873cf2e07bdc7fd1e72169aee2a19fa40d7Mathias Agopian } 1998386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian 199928378392fd5aa3e0a392c9eb64634055678c3987Jamie Gennis if (transactionFlags) { 2000386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian // this triggers the transaction 200128378392fd5aa3e0a392c9eb64634055678c3987Jamie Gennis setTransactionFlags(transactionFlags); 2002698c0873cf2e07bdc7fd1e72169aee2a19fa40d7Mathias Agopian 2003386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian // if this is a synchronous transaction, wait for it to take effect 2004386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian // before returning. 2005386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian if (flags & eSynchronous) { 20062d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis mTransactionPending = true; 20072d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis } 20082d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis if (flags & eAnimation) { 20092d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis mAnimTransactionPending = true; 2010386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian } 20112d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis while (mTransactionPending) { 2012386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5)); 2013386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian if (CC_UNLIKELY(err != NO_ERROR)) { 2014386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian // just in case something goes wrong in SF, return to the 2015386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian // called after a few seconds. 20162d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!"); 20172d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis mTransactionPending = false; 2018386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian break; 2019386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian } 2020cbb288bfe89f585bf48371bd31b2d4aafa32f32eMathias Agopian } 2021edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 2022edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 2023edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 2024e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopianuint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s) 2025e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian{ 20269a14392256354538f1f43a5e80fe46c2c2b965cbJesse Hall ssize_t dpyIdx = mCurrentState.displays.indexOfKey(s.token); 20279a14392256354538f1f43a5e80fe46c2c2b965cbJesse Hall if (dpyIdx < 0) 20289a14392256354538f1f43a5e80fe46c2c2b965cbJesse Hall return 0; 20299a14392256354538f1f43a5e80fe46c2c2b965cbJesse Hall 2030e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian uint32_t flags = 0; 20319a14392256354538f1f43a5e80fe46c2c2b965cbJesse Hall DisplayDeviceState& disp(mCurrentState.displays.editValueAt(dpyIdx)); 20323ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias Agopian if (disp.isValid()) { 2033e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian const uint32_t what = s.what; 2034e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (what & DisplayState::eSurfaceChanged) { 2035097ca275f4717a2c47a5d49f302ed2b72c8a1370Marco Nelissen if (IInterface::asBinder(disp.surface) != IInterface::asBinder(s.surface)) { 2036e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian disp.surface = s.surface; 2037e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eDisplayTransactionNeeded; 2038e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2039e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2040e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (what & DisplayState::eLayerStackChanged) { 2041e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (disp.layerStack != s.layerStack) { 2042e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian disp.layerStack = s.layerStack; 2043e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eDisplayTransactionNeeded; 2044e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2045e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 204600e8c7a88a5b9c4104a71013a713acd3e4d3b77bMathias Agopian if (what & DisplayState::eDisplayProjectionChanged) { 2047e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (disp.orientation != s.orientation) { 2048e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian disp.orientation = s.orientation; 2049e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eDisplayTransactionNeeded; 2050e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2051e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (disp.frame != s.frame) { 2052e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian disp.frame = s.frame; 2053e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eDisplayTransactionNeeded; 2054e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2055e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (disp.viewport != s.viewport) { 2056e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian disp.viewport = s.viewport; 2057e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eDisplayTransactionNeeded; 2058e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2059e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 206047e45405d1533aa73307014f7bf371e118695cf3Michael Lentine if (what & DisplayState::eDisplaySizeChanged) { 206147e45405d1533aa73307014f7bf371e118695cf3Michael Lentine if (disp.width != s.width) { 206247e45405d1533aa73307014f7bf371e118695cf3Michael Lentine disp.width = s.width; 206347e45405d1533aa73307014f7bf371e118695cf3Michael Lentine flags |= eDisplayTransactionNeeded; 206447e45405d1533aa73307014f7bf371e118695cf3Michael Lentine } 206547e45405d1533aa73307014f7bf371e118695cf3Michael Lentine if (disp.height != s.height) { 206647e45405d1533aa73307014f7bf371e118695cf3Michael Lentine disp.height = s.height; 206747e45405d1533aa73307014f7bf371e118695cf3Michael Lentine flags |= eDisplayTransactionNeeded; 206847e45405d1533aa73307014f7bf371e118695cf3Michael Lentine } 206947e45405d1533aa73307014f7bf371e118695cf3Michael Lentine } 2070e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2071e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian return flags; 2072e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian} 2073e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian 2074e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopianuint32_t SurfaceFlinger::setClientStateLocked( 2075e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian const sp<Client>& client, 2076e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian const layer_state_t& s) 2077e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian{ 2078e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian uint32_t flags = 0; 207913127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian sp<Layer> layer(client->getLayerUser(s.surface)); 2080e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (layer != 0) { 2081e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian const uint32_t what = s.what; 2082e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (what & layer_state_t::ePositionChanged) { 2083e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (layer->setPosition(s.x, s.y)) 2084e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eTraversalNeeded; 2085e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2086e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (what & layer_state_t::eLayerChanged) { 2087e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian // NOTE: index needs to be calculated before we update the state 2088e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer); 2089e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (layer->setLayer(s.z)) { 2090e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian mCurrentState.layersSortedByZ.removeAt(idx); 2091e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian mCurrentState.layersSortedByZ.add(layer); 2092e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian // we need traversal (state changed) 2093e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian // AND transaction (list changed) 2094e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eTransactionNeeded|eTraversalNeeded; 2095e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2096e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2097e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (what & layer_state_t::eSizeChanged) { 2098e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (layer->setSize(s.w, s.h)) { 2099e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eTraversalNeeded; 2100e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2101e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2102e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (what & layer_state_t::eAlphaChanged) { 2103e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (layer->setAlpha(uint8_t(255.0f*s.alpha+0.5f))) 2104e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eTraversalNeeded; 2105e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2106e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (what & layer_state_t::eMatrixChanged) { 2107e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (layer->setMatrix(s.matrix)) 2108e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eTraversalNeeded; 2109e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2110e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (what & layer_state_t::eTransparentRegionChanged) { 2111e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (layer->setTransparentRegionHint(s.transparentRegion)) 2112e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eTraversalNeeded; 2113e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 21144125a4ffaf374ca9c0773f256998557d3325343eAndy McFadden if ((what & layer_state_t::eVisibilityChanged) || 21154125a4ffaf374ca9c0773f256998557d3325343eAndy McFadden (what & layer_state_t::eOpacityChanged)) { 21164125a4ffaf374ca9c0773f256998557d3325343eAndy McFadden // TODO: should we just use an eFlagsChanged for this? 2117e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (layer->setFlags(s.flags, s.mask)) 2118e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eTraversalNeeded; 2119e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2120e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (what & layer_state_t::eCropChanged) { 2121e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (layer->setCrop(s.crop)) 2122e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eTraversalNeeded; 2123e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2124e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (what & layer_state_t::eLayerStackChanged) { 2125e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian // NOTE: index needs to be calculated before we update the state 2126e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer); 2127e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (layer->setLayerStack(s.layerStack)) { 2128e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian mCurrentState.layersSortedByZ.removeAt(idx); 2129e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian mCurrentState.layersSortedByZ.add(layer); 2130e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian // we need traversal (state changed) 2131e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian // AND transaction (list changed) 2132e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eTransactionNeeded|eTraversalNeeded; 2133e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2134e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2135e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2136e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian return flags; 2137e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian} 2138e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian 21394d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopianstatus_t SurfaceFlinger::createLayer( 21400ef4e15a6c12778daf464a4953d7e15e651f49acMathias Agopian const String8& name, 21410ef4e15a6c12778daf464a4953d7e15e651f49acMathias Agopian const sp<Client>& client, 21424d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian uint32_t w, uint32_t h, PixelFormat format, uint32_t flags, 21434d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp) 2144edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 21454d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian //ALOGD("createLayer for (%d x %d), name=%s", w, h, name.string()); 21466e2d6483fe14362187c78c91dc03024fbb31d431Mathias Agopian if (int32_t(w|h) < 0) { 2147921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)", 21486e2d6483fe14362187c78c91dc03024fbb31d431Mathias Agopian int(w), int(h)); 21494d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian return BAD_VALUE; 21506e2d6483fe14362187c78c91dc03024fbb31d431Mathias Agopian } 21518b42e8a5d87dcdc8ea31368ab88de49b72ab5432Andreas Huber 21524d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian status_t result = NO_ERROR; 21534d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian 21544d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian sp<Layer> layer; 21554d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian 21563165cc21cfea781988407b19bd83292b19f05f55Mathias Agopian switch (flags & ISurfaceComposerClient::eFXSurfaceMask) { 21573165cc21cfea781988407b19bd83292b19f05f55Mathias Agopian case ISurfaceComposerClient::eFXSurfaceNormal: 21584d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian result = createNormalLayer(client, 21594d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian name, w, h, flags, format, 21604d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian handle, gbp, &layer); 2161edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project break; 21623165cc21cfea781988407b19bd83292b19f05f55Mathias Agopian case ISurfaceComposerClient::eFXSurfaceDim: 21634d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian result = createDimLayer(client, 21644d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian name, w, h, flags, 21654d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian handle, gbp, &layer); 21664d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian break; 21674d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian default: 21684d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian result = BAD_VALUE; 2169edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project break; 2170edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 2171edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 21724d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian if (result == NO_ERROR) { 21736710604286401d4205c27235a252dd0e5008cc08Mathias Agopian addClientLayer(client, *handle, *gbp, layer); 217496f0819f81293076e652792794a961543e6750d7Mathias Agopian setTransactionFlags(eTransactionNeeded); 2175edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 21764d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian return result; 2177edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 2178edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 21794d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopianstatus_t SurfaceFlinger::createNormalLayer(const sp<Client>& client, 21804d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian const String8& name, uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format, 21814d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer) 2182edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 2183edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project // initialize the surfaces 218492a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian switch (format) { 2185edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project case PIXEL_FORMAT_TRANSPARENT: 2186edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project case PIXEL_FORMAT_TRANSLUCENT: 2187edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project format = PIXEL_FORMAT_RGBA_8888; 2188edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project break; 2189edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project case PIXEL_FORMAT_OPAQUE: 21908f10540cd59e980dcdb5a8f4f2dbec0d94177f5fMathias Agopian format = PIXEL_FORMAT_RGBX_8888; 2191edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project break; 2192edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 2193edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 21944d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian *outLayer = new Layer(this, client, name, w, h, flags); 21954d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian status_t err = (*outLayer)->setBuffers(w, h, format, flags); 21964d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian if (err == NO_ERROR) { 21974d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian *handle = (*outLayer)->getHandle(); 2198b9b088375d33a87b201cdbe18be71802e2607717Dan Stoza *gbp = (*outLayer)->getProducer(); 2199edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 22004d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian 22014d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian ALOGE_IF(err, "createNormalLayer() failed (%s)", strerror(-err)); 22024d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian return err; 2203edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 2204edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 22054d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopianstatus_t SurfaceFlinger::createDimLayer(const sp<Client>& client, 22064d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian const String8& name, uint32_t w, uint32_t h, uint32_t flags, 22074d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer) 2208edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 22094d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian *outLayer = new LayerDim(this, client, name, w, h, flags); 22104d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian *handle = (*outLayer)->getHandle(); 2211b9b088375d33a87b201cdbe18be71802e2607717Dan Stoza *gbp = (*outLayer)->getProducer(); 22124d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian return NO_ERROR; 2213118d0245ee0a3b107055782aa8b555404b6f0280Mathias Agopian} 2214118d0245ee0a3b107055782aa8b555404b6f0280Mathias Agopian 2215ac9fa427d4a86745e60a5f7fd8e3ea340c4db907Mathias Agopianstatus_t SurfaceFlinger::onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle) 22169a11206fe793363c0e8897b478cbe6ef8c52b543Mathias Agopian{ 22176710604286401d4205c27235a252dd0e5008cc08Mathias Agopian // called by the window manager when it wants to remove a Layer 22186710604286401d4205c27235a252dd0e5008cc08Mathias Agopian status_t err = NO_ERROR; 22196710604286401d4205c27235a252dd0e5008cc08Mathias Agopian sp<Layer> l(client->getLayerUser(handle)); 22206710604286401d4205c27235a252dd0e5008cc08Mathias Agopian if (l != NULL) { 22216710604286401d4205c27235a252dd0e5008cc08Mathias Agopian err = removeLayer(l); 22226710604286401d4205c27235a252dd0e5008cc08Mathias Agopian ALOGE_IF(err<0 && err != NAME_NOT_FOUND, 22236710604286401d4205c27235a252dd0e5008cc08Mathias Agopian "error removing layer=%p (%s)", l.get(), strerror(-err)); 22249a11206fe793363c0e8897b478cbe6ef8c52b543Mathias Agopian } 22259a11206fe793363c0e8897b478cbe6ef8c52b543Mathias Agopian return err; 22269a11206fe793363c0e8897b478cbe6ef8c52b543Mathias Agopian} 22279a11206fe793363c0e8897b478cbe6ef8c52b543Mathias Agopian 222813127d8921356dff794250e04208c3ed60b3a3dfMathias Agopianstatus_t SurfaceFlinger::onLayerDestroyed(const wp<Layer>& layer) 2229edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 22306710604286401d4205c27235a252dd0e5008cc08Mathias Agopian // called by ~LayerCleaner() when all references to the IBinder (handle) 22316710604286401d4205c27235a252dd0e5008cc08Mathias Agopian // are gone 2232ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian status_t err = NO_ERROR; 223313127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian sp<Layer> l(layer.promote()); 2234ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian if (l != NULL) { 22356710604286401d4205c27235a252dd0e5008cc08Mathias Agopian err = removeLayer(l); 2236e6f43ddce78d6846af12550ff9193c5c6fe5844bSteve Block ALOGE_IF(err<0 && err != NAME_NOT_FOUND, 2237ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian "error removing layer=%p (%s)", l.get(), strerror(-err)); 2238ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian } 2239ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian return err; 2240edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 2241edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 2242b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian// --------------------------------------------------------------------------- 2243b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian 224413a082e160c2d1d8006b93a555a57035213d568bAndy McFaddenvoid SurfaceFlinger::onInitializeDisplays() { 224501e29054e672301e4adbbca15b3562a59a20f267Jesse Hall // reset screen orientation and use primary layer stack 224613a082e160c2d1d8006b93a555a57035213d568bAndy McFadden Vector<ComposerState> state; 224713a082e160c2d1d8006b93a555a57035213d568bAndy McFadden Vector<DisplayState> displays; 224813a082e160c2d1d8006b93a555a57035213d568bAndy McFadden DisplayState d; 224901e29054e672301e4adbbca15b3562a59a20f267Jesse Hall d.what = DisplayState::eDisplayProjectionChanged | 225001e29054e672301e4adbbca15b3562a59a20f267Jesse Hall DisplayState::eLayerStackChanged; 2251692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall d.token = mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY]; 225201e29054e672301e4adbbca15b3562a59a20f267Jesse Hall d.layerStack = 0; 225313a082e160c2d1d8006b93a555a57035213d568bAndy McFadden d.orientation = DisplayState::eOrientationDefault; 22544c05dd175ee3bd5119eecf368742b6510a8cfa6cJeff Brown d.frame.makeInvalid(); 22554c05dd175ee3bd5119eecf368742b6510a8cfa6cJeff Brown d.viewport.makeInvalid(); 225647e45405d1533aa73307014f7bf371e118695cf3Michael Lentine d.width = 0; 225747e45405d1533aa73307014f7bf371e118695cf3Michael Lentine d.height = 0; 225813a082e160c2d1d8006b93a555a57035213d568bAndy McFadden displays.add(d); 225913a082e160c2d1d8006b93a555a57035213d568bAndy McFadden setTransactionState(state, displays, 0); 22602c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani setPowerModeInternal(getDisplayDevice(d.token), HWC_POWER_MODE_NORMAL); 22616547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis 22626547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis const nsecs_t period = 22636547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY); 22646547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis mAnimFrameTracker.setDisplayRefreshPeriod(period); 226513a082e160c2d1d8006b93a555a57035213d568bAndy McFadden} 226613a082e160c2d1d8006b93a555a57035213d568bAndy McFadden 226713a082e160c2d1d8006b93a555a57035213d568bAndy McFaddenvoid SurfaceFlinger::initializeDisplays() { 226813a082e160c2d1d8006b93a555a57035213d568bAndy McFadden class MessageScreenInitialized : public MessageBase { 226913a082e160c2d1d8006b93a555a57035213d568bAndy McFadden SurfaceFlinger* flinger; 227013a082e160c2d1d8006b93a555a57035213d568bAndy McFadden public: 227113a082e160c2d1d8006b93a555a57035213d568bAndy McFadden MessageScreenInitialized(SurfaceFlinger* flinger) : flinger(flinger) { } 227213a082e160c2d1d8006b93a555a57035213d568bAndy McFadden virtual bool handler() { 227313a082e160c2d1d8006b93a555a57035213d568bAndy McFadden flinger->onInitializeDisplays(); 227413a082e160c2d1d8006b93a555a57035213d568bAndy McFadden return true; 227513a082e160c2d1d8006b93a555a57035213d568bAndy McFadden } 227613a082e160c2d1d8006b93a555a57035213d568bAndy McFadden }; 227713a082e160c2d1d8006b93a555a57035213d568bAndy McFadden sp<MessageBase> msg = new MessageScreenInitialized(this); 227813a082e160c2d1d8006b93a555a57035213d568bAndy McFadden postMessageAsync(msg); // we may be called from main thread, use async message 227913a082e160c2d1d8006b93a555a57035213d568bAndy McFadden} 228013a082e160c2d1d8006b93a555a57035213d568bAndy McFadden 22812c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malanivoid SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& hw, 22822c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani int mode) { 22832c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani ALOGD("Set power mode=%d, type=%d flinger=%p", mode, hw->getDisplayType(), 22842c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani this); 22852c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani int32_t type = hw->getDisplayType(); 22862c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani int currentMode = hw->getPowerMode(); 228713a082e160c2d1d8006b93a555a57035213d568bAndy McFadden 22882c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani if (mode == currentMode) { 22892c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani ALOGD("Screen type=%d is already mode=%d", hw->getDisplayType(), mode); 2290c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden return; 2291c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden } 2292c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden 22932c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani hw->setPowerMode(mode); 22942c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani if (type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) { 22952c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani ALOGW("Trying to set power mode for virtual display"); 22962c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani return; 22972c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani } 2298c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden 22992c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani if (currentMode == HWC_POWER_MODE_OFF) { 23002c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani getHwComposer().setPowerMode(type, mode); 2301c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden if (type == DisplayDevice::DISPLAY_PRIMARY) { 2302c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden // FIXME: eventthread only knows about the main display right now 2303c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden mEventThread->onScreenAcquired(); 2304948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall resyncToHardwareVsync(true); 2305c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden } 2306edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 23072c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani mVisibleRegionsDirty = true; 23082c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani repaintEverything(); 23092c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani } else if (mode == HWC_POWER_MODE_OFF) { 2310c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden if (type == DisplayDevice::DISPLAY_PRIMARY) { 2311948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall disableHardwareVsync(true); // also cancels any in-progress resync 2312948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall 2313cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian // FIXME: eventthread only knows about the main display right now 2314cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian mEventThread->onScreenReleased(); 2315cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian } 2316c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden 23172c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani getHwComposer().setPowerMode(type, mode); 23182c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani mVisibleRegionsDirty = true; 23192c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani // from this point on, SF will stop drawing on this display 23202c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani } else { 23212c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani getHwComposer().setPowerMode(type, mode); 2322b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian } 2323edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 2324edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 23252c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malanivoid SurfaceFlinger::setPowerMode(const sp<IBinder>& display, int mode) { 23262c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani class MessageSetPowerMode: public MessageBase { 2327db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian SurfaceFlinger& mFlinger; 2328db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian sp<IBinder> mDisplay; 23292c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani int mMode; 2330b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian public: 23312c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani MessageSetPowerMode(SurfaceFlinger& flinger, 23322c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani const sp<IBinder>& disp, int mode) : mFlinger(flinger), 23332c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani mDisplay(disp) { mMode = mode; } 2334b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian virtual bool handler() { 23352c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay)); 2336db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian if (hw == NULL) { 23372c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani ALOGE("Attempt to set power mode = %d for null display %p", 23387306c670eb3ddb471d983a7458eb9f522afd0763Michael Lentine mMode, mDisplay.get()); 23399e663de4fe1dcc872373ee530c60a375624671c3Jesse Hall } else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) { 23402c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani ALOGW("Attempt to set power mode = %d for virtual display", 23412c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani mMode); 2342db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian } else { 23432c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani mFlinger.setPowerModeInternal(hw, mMode); 2344db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian } 2345b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian return true; 2346b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian } 2347b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian }; 23482c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani sp<MessageBase> msg = new MessageSetPowerMode(*this, display, mode); 2349db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian postMessageSync(msg); 2350b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian} 2351b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian 2352b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian// --------------------------------------------------------------------------- 2353b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian 2354edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Projectstatus_t SurfaceFlinger::dump(int fd, const Vector<String16>& args) 2355edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 2356edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project String8 result; 235799b49840d309727678b77403d6cc9f920111623fMathias Agopian 2358bd1153382e7a9d89922bea999a52ca21d46d6caaMathias Agopian IPCThreadState* ipc = IPCThreadState::self(); 2359bd1153382e7a9d89922bea999a52ca21d46d6caaMathias Agopian const int pid = ipc->getCallingPid(); 2360bd1153382e7a9d89922bea999a52ca21d46d6caaMathias Agopian const int uid = ipc->getCallingUid(); 2361bd1153382e7a9d89922bea999a52ca21d46d6caaMathias Agopian if ((uid != AID_SHELL) && 2362bd1153382e7a9d89922bea999a52ca21d46d6caaMathias Agopian !PermissionCache::checkPermission(sDump, pid, uid)) { 236374d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian result.appendFormat("Permission Denial: " 2364bd1153382e7a9d89922bea999a52ca21d46d6caaMathias Agopian "can't dump SurfaceFlinger from pid=%d, uid=%d\n", pid, uid); 2365edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } else { 2366fcd15b478c20f579388bb1368f05098dca534639Jesse Hall // Try to get the main lock, but give up after one second 23679795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian // (this would indicate SF is stuck, but we want to be able to 23689795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian // print something in dumpsys). 2369fcd15b478c20f579388bb1368f05098dca534639Jesse Hall status_t err = mStateLock.timedLock(s2ns(1)); 2370fcd15b478c20f579388bb1368f05098dca534639Jesse Hall bool locked = (err == NO_ERROR); 23719795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian if (!locked) { 2372fcd15b478c20f579388bb1368f05098dca534639Jesse Hall result.appendFormat( 2373fcd15b478c20f579388bb1368f05098dca534639Jesse Hall "SurfaceFlinger appears to be unresponsive (%s [%d]), " 2374fcd15b478c20f579388bb1368f05098dca534639Jesse Hall "dumping anyways (no locks held)\n", strerror(-err), err); 23759795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian } 23769795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian 237782d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian bool dumpAll = true; 237882d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian size_t index = 0; 237925e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian size_t numArgs = args.size(); 238025e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian if (numArgs) { 238125e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian if ((index < numArgs) && 238225e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian (args[index] == String16("--list"))) { 238325e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian index++; 238474d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian listLayersLocked(args, index, result); 238535aadd6be249da4bd4851692e6aff757c91b32a7Mathias Agopian dumpAll = false; 238625e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian } 238725e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian 238825e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian if ((index < numArgs) && 238925e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian (args[index] == String16("--latency"))) { 239082d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian index++; 239174d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian dumpStatsLocked(args, index, result); 239235aadd6be249da4bd4851692e6aff757c91b32a7Mathias Agopian dumpAll = false; 239382d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian } 239425e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian 239525e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian if ((index < numArgs) && 239625e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian (args[index] == String16("--latency-clear"))) { 239725e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian index++; 239874d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian clearStatsLocked(args, index, result); 239935aadd6be249da4bd4851692e6aff757c91b32a7Mathias Agopian dumpAll = false; 240025e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian } 2401c751e92c56de5f335a36e68607c7a6c627dcd0dcAndy McFadden 2402c751e92c56de5f335a36e68607c7a6c627dcd0dcAndy McFadden if ((index < numArgs) && 2403c751e92c56de5f335a36e68607c7a6c627dcd0dcAndy McFadden (args[index] == String16("--dispsync"))) { 2404c751e92c56de5f335a36e68607c7a6c627dcd0dcAndy McFadden index++; 2405c751e92c56de5f335a36e68607c7a6c627dcd0dcAndy McFadden mPrimaryDispSync.dump(result); 2406c751e92c56de5f335a36e68607c7a6c627dcd0dcAndy McFadden dumpAll = false; 2407c751e92c56de5f335a36e68607c7a6c627dcd0dcAndy McFadden } 2408edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 24091b5e1021b8c9b87113b70d94dfb7b50f8c5b01b8Mathias Agopian 241082d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian if (dumpAll) { 241174d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian dumpAllLocked(args, index, result); 241282d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian } 241348b888aab9fdcfba250722dffbdffe61f11c64f3Mathias Agopian 241482d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian if (locked) { 241582d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian mStateLock.unlock(); 241648b888aab9fdcfba250722dffbdffe61f11c64f3Mathias Agopian } 241782d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian } 241882d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian write(fd, result.string(), result.size()); 241982d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian return NO_ERROR; 242082d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian} 242148b888aab9fdcfba250722dffbdffe61f11c64f3Mathias Agopian 2422c701401f8cec2e5309f8b57e2b97baced5093274Dan Stozavoid SurfaceFlinger::listLayersLocked(const Vector<String16>& /* args */, 2423c701401f8cec2e5309f8b57e2b97baced5093274Dan Stoza size_t& /* index */, String8& result) const 242425e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian{ 242525e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian const LayerVector& currentLayers = mCurrentState.layersSortedByZ; 242625e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian const size_t count = currentLayers.size(); 242725e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian for (size_t i=0 ; i<count ; i++) { 242813127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer(currentLayers[i]); 242974d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian result.appendFormat("%s\n", layer->getName().string()); 243025e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian } 243125e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian} 243225e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian 243382d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopianvoid SurfaceFlinger::dumpStatsLocked(const Vector<String16>& args, size_t& index, 243474d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian String8& result) const 243582d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian{ 243682d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian String8 name; 243782d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian if (index < args.size()) { 243882d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian name = String8(args[index]); 243982d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian index++; 244082d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian } 244148b888aab9fdcfba250722dffbdffe61f11c64f3Mathias Agopian 24424b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis const nsecs_t period = 24434b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY); 244486efcc0cbc1d94250b72ef1f2ea8700a04cd2781Greg Hackmann result.appendFormat("%" PRId64 "\n", period); 24454b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis 24464b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis if (name.isEmpty()) { 2447d85084b2b65828442eafaff9b811e9b6c9ca9fadSvetoslav mAnimFrameTracker.dumpStats(result); 24484b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis } else { 24494b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis const LayerVector& currentLayers = mCurrentState.layersSortedByZ; 24504b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis const size_t count = currentLayers.size(); 24514b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis for (size_t i=0 ; i<count ; i++) { 245213127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer(currentLayers[i]); 24534b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis if (name == layer->getName()) { 2454d85084b2b65828442eafaff9b811e9b6c9ca9fadSvetoslav layer->dumpFrameStats(result); 24554b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis } 245682d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian } 245782d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian } 245882d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian} 2459ad70186f80355e55ddad2a66b5fd174a1c019c2dMathias Agopian 246025e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopianvoid SurfaceFlinger::clearStatsLocked(const Vector<String16>& args, size_t& index, 2461c701401f8cec2e5309f8b57e2b97baced5093274Dan Stoza String8& /* result */) 246225e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian{ 246325e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian String8 name; 246425e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian if (index < args.size()) { 246525e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian name = String8(args[index]); 246625e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian index++; 246725e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian } 246825e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian 246925e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian const LayerVector& currentLayers = mCurrentState.layersSortedByZ; 247025e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian const size_t count = currentLayers.size(); 247125e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian for (size_t i=0 ; i<count ; i++) { 247213127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer(currentLayers[i]); 247325e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian if (name.isEmpty() || (name == layer->getName())) { 2474d85084b2b65828442eafaff9b811e9b6c9ca9fadSvetoslav layer->clearFrameStats(); 247525e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian } 247625e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian } 24774b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis 2478d85084b2b65828442eafaff9b811e9b6c9ca9fadSvetoslav mAnimFrameTracker.clearStats(); 247925e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian} 248025e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian 24816547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis// This should only be called from the main thread. Otherwise it would need 24826547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis// the lock and should use mCurrentState rather than mDrawingState. 24836547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennisvoid SurfaceFlinger::logFrameStats() { 24846547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis const LayerVector& drawingLayers = mDrawingState.layersSortedByZ; 24856547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis const size_t count = drawingLayers.size(); 24866547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis for (size_t i=0 ; i<count ; i++) { 24876547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis const sp<Layer>& layer(drawingLayers[i]); 24886547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis layer->logFrameStats(); 24896547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis } 24906547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis 24916547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis mAnimFrameTracker.logAndResetStats(String8("<win-anim>")); 24926547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis} 24936547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis 24944803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden/*static*/ void SurfaceFlinger::appendSfConfigString(String8& result) 24954803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden{ 24964803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden static const char* config = 24974803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden " [sf" 24984803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden#ifdef HAS_CONTEXT_PRIORITY 24994803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden " HAS_CONTEXT_PRIORITY" 25004803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden#endif 25014803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden#ifdef NEVER_DEFAULT_TO_ASYNC_MODE 25024803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden " NEVER_DEFAULT_TO_ASYNC_MODE" 25034803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden#endif 25044803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden#ifdef TARGET_DISABLE_TRIPLE_BUFFERING 25054803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden " TARGET_DISABLE_TRIPLE_BUFFERING" 25064803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden#endif 25074803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden "]"; 25084803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden result.append(config); 25094803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden} 25104803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden 251174d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopianvoid SurfaceFlinger::dumpAllLocked(const Vector<String16>& args, size_t& index, 251274d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian String8& result) const 251382d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian{ 25143e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian bool colorize = false; 25153e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian if (index < args.size() 25163e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian && (args[index] == String16("--color"))) { 25173e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorize = true; 25183e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian index++; 25193e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian } 25203e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian 25213e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian Colorizer colorizer(colorize); 25223e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian 252382d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian // figure out if we're stuck somewhere 252482d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian const nsecs_t now = systemTime(); 252582d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian const nsecs_t inSwapBuffers(mDebugInSwapBuffers); 252682d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian const nsecs_t inTransaction(mDebugInTransaction); 252782d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian nsecs_t inSwapBuffersDuration = (inSwapBuffers) ? now-inSwapBuffers : 0; 252882d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0; 2529bc2d79ed7ada6243f3690f94ab512c0ddcdbed12Mathias Agopian 253082d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian /* 25314803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden * Dump library configuration. 25324803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden */ 25333e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian 25343e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.bold(result); 25354803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden result.append("Build configuration:"); 25363e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.reset(result); 25374803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden appendSfConfigString(result); 25384803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden appendUiConfigString(result); 25394803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden appendGuiConfigString(result); 25404803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden result.append("\n"); 25414803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden 25423e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.bold(result); 2543ca08833d5ea99130797e10ad68a651b50e99da74Mathias Agopian result.append("Sync configuration: "); 25443e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.reset(result); 2545ca08833d5ea99130797e10ad68a651b50e99da74Mathias Agopian result.append(SyncFeatures::getInstance().toString()); 2546ca08833d5ea99130797e10ad68a651b50e99da74Mathias Agopian result.append("\n"); 2547ca08833d5ea99130797e10ad68a651b50e99da74Mathias Agopian 254841d67d7ab4da1c393497a620a116a854b3c618e7Andy McFadden colorizer.bold(result); 254941d67d7ab4da1c393497a620a116a854b3c618e7Andy McFadden result.append("DispSync configuration: "); 255041d67d7ab4da1c393497a620a116a854b3c618e7Andy McFadden colorizer.reset(result); 255124cd98eef88ac93f80c327f8d74f0a1ae0aceee4Jesse Hall result.appendFormat("app phase %" PRId64 " ns, sf phase %" PRId64 " ns, " 255224cd98eef88ac93f80c327f8d74f0a1ae0aceee4Jesse Hall "present offset %d ns (refresh %" PRId64 " ns)", 255341d67d7ab4da1c393497a620a116a854b3c618e7Andy McFadden vsyncPhaseOffsetNs, sfVsyncPhaseOffsetNs, PRESENT_TIME_OFFSET_FROM_VSYNC_NS, 255441d67d7ab4da1c393497a620a116a854b3c618e7Andy McFadden mHwc->getRefreshPeriod(HWC_DISPLAY_PRIMARY)); 255541d67d7ab4da1c393497a620a116a854b3c618e7Andy McFadden result.append("\n"); 255641d67d7ab4da1c393497a620a116a854b3c618e7Andy McFadden 25574803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden /* 255882d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian * Dump the visible layer list 255982d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian */ 256082d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian const LayerVector& currentLayers = mCurrentState.layersSortedByZ; 256182d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian const size_t count = currentLayers.size(); 25623e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.bold(result); 256386efcc0cbc1d94250b72ef1f2ea8700a04cd2781Greg Hackmann result.appendFormat("Visible layers (count = %zu)\n", count); 25643e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.reset(result); 256582d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian for (size_t i=0 ; i<count ; i++) { 256613127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer(currentLayers[i]); 25673e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian layer->dump(result, colorizer); 256882d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian } 2569bc2d79ed7ada6243f3690f94ab512c0ddcdbed12Mathias Agopian 257082d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian /* 25715f20e2d4462da3471f59152b32cd8640fa4a21daMathias Agopian * Dump Display state 25725f20e2d4462da3471f59152b32cd8640fa4a21daMathias Agopian */ 25735f20e2d4462da3471f59152b32cd8640fa4a21daMathias Agopian 25743e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.bold(result); 257586efcc0cbc1d94250b72ef1f2ea8700a04cd2781Greg Hackmann result.appendFormat("Displays (%zu entries)\n", mDisplays.size()); 25763e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.reset(result); 25775f20e2d4462da3471f59152b32cd8640fa4a21daMathias Agopian for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 25785f20e2d4462da3471f59152b32cd8640fa4a21daMathias Agopian const sp<const DisplayDevice>& hw(mDisplays[dpy]); 257974d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian hw->dump(result); 25805f20e2d4462da3471f59152b32cd8640fa4a21daMathias Agopian } 25815f20e2d4462da3471f59152b32cd8640fa4a21daMathias Agopian 25825f20e2d4462da3471f59152b32cd8640fa4a21daMathias Agopian /* 258382d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian * Dump SurfaceFlinger global state 258482d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian */ 25851b5e1021b8c9b87113b70d94dfb7b50f8c5b01b8Mathias Agopian 25863e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.bold(result); 258774d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian result.append("SurfaceFlinger global state:\n"); 25883e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.reset(result); 25891b5e1021b8c9b87113b70d94dfb7b50f8c5b01b8Mathias Agopian 2590888c822c4cb6976aab9256c58bae9e17e3e55c5cMathias Agopian HWComposer& hwc(getHwComposer()); 25914297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian sp<const DisplayDevice> hw(getDefaultDisplayDevice()); 2592ca08833d5ea99130797e10ad68a651b50e99da74Mathias Agopian 25933e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.bold(result); 25943e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian result.appendFormat("EGL implementation : %s\n", 25953e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian eglQueryStringImplementationANDROID(mEGLDisplay, EGL_VERSION)); 25963e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.reset(result); 25973e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian result.appendFormat("%s\n", 2598ca08833d5ea99130797e10ad68a651b50e99da74Mathias Agopian eglQueryStringImplementationANDROID(mEGLDisplay, EGL_EXTENSIONS)); 2599ca08833d5ea99130797e10ad68a651b50e99da74Mathias Agopian 2600875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian mRenderEngine->dump(result); 26019795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian 26024297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian hw->undefinedRegion.dump(result, "undefinedRegion"); 26032c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani result.appendFormat(" orientation=%d, isDisplayOn=%d\n", 26042c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani hw->getOrientation(), hw->isDisplayOn()); 260574d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian result.appendFormat( 260682d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian " last eglSwapBuffers() time: %f us\n" 260782d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian " last transaction time : %f us\n" 2608c95dbdc236acf002b5f8aed8c8a9e43047fc75b5Mathias Agopian " transaction-flags : %08x\n" 260982d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian " refresh-rate : %f fps\n" 261082d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian " x-dpi : %f\n" 2611ed985574148a938bc3af24442eead313cc62521cMathias Agopian " y-dpi : %f\n" 2612ed985574148a938bc3af24442eead313cc62521cMathias Agopian " gpu_to_cpu_unsupported : %d\n" 2613ed985574148a938bc3af24442eead313cc62521cMathias Agopian , 261482d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian mLastSwapBufferTime/1000.0, 261582d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian mLastTransactionTime/1000.0, 2616c95dbdc236acf002b5f8aed8c8a9e43047fc75b5Mathias Agopian mTransactionFlags, 2617b0d1dd36f104c0b581674adc7f830cbf44b7db06Andy McFadden 1e9 / hwc.getRefreshPeriod(HWC_DISPLAY_PRIMARY), 2618b0d1dd36f104c0b581674adc7f830cbf44b7db06Andy McFadden hwc.getDpiX(HWC_DISPLAY_PRIMARY), 2619ed985574148a938bc3af24442eead313cc62521cMathias Agopian hwc.getDpiY(HWC_DISPLAY_PRIMARY), 2620ed985574148a938bc3af24442eead313cc62521cMathias Agopian !mGpuToCpuSupported); 262182d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian 262274d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian result.appendFormat(" eglSwapBuffers time: %f us\n", 262382d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian inSwapBuffersDuration/1000.0); 262482d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian 262574d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian result.appendFormat(" transaction time: %f us\n", 262682d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian inTransactionDuration/1000.0); 262782d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian 262882d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian /* 262982d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian * VSYNC state 263082d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian */ 263174d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian mEventThread->dump(result); 263282d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian 263382d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian /* 263482d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian * Dump HWComposer state 263582d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian */ 26363e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.bold(result); 263774d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian result.append("h/w composer state:\n"); 26383e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.reset(result); 263974d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian result.appendFormat(" h/w composer %s and %s\n", 264082d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian hwc.initCheck()==NO_ERROR ? "present" : "not present", 26419c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette (mDebugDisableHWC || mDebugRegion || mDaltonize 26429c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette || mHasColorMatrix) ? "disabled" : "enabled"); 264374d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian hwc.dump(result); 264482d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian 264582d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian /* 264682d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian * Dump gralloc state 264782d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian */ 264882d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get()); 264982d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian alloc.dump(result); 2650edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 2651edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 265213127d8921356dff794250e04208c3ed60b3a3dfMathias Agopianconst Vector< sp<Layer> >& 265348bc05b56df9919fc39c5f2e3ea6535560eec98fJesse HallSurfaceFlinger::getLayerSortedByZForHwcDisplay(int id) { 2654db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian // Note: mStateLock is held here 265548bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall wp<IBinder> dpy; 265648bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall for (size_t i=0 ; i<mDisplays.size() ; i++) { 265748bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall if (mDisplays.valueAt(i)->getHwcDisplayId() == id) { 265848bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall dpy = mDisplays.keyAt(i); 265948bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall break; 266048bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall } 266148bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall } 266248bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall if (dpy == NULL) { 266348bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall ALOGE("getLayerSortedByZForHwcDisplay: invalid hwc display id %d", id); 266448bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall // Just use the primary display so we have something to return 266548bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall dpy = getBuiltInDisplay(DisplayDevice::DISPLAY_PRIMARY); 266648bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall } 266748bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall return getDisplayDevice(dpy)->getVisibleLayersSortedByZ(); 2668cb55857bbde34a06c19dde3db5064d1717a0173eMathias Agopian} 2669cb55857bbde34a06c19dde3db5064d1717a0173eMathias Agopian 267063f165fd6b86d04be94d4023e845e98560504a96Keun young Parkbool SurfaceFlinger::startDdmConnection() 267163f165fd6b86d04be94d4023e845e98560504a96Keun young Park{ 267263f165fd6b86d04be94d4023e845e98560504a96Keun young Park void* libddmconnection_dso = 267363f165fd6b86d04be94d4023e845e98560504a96Keun young Park dlopen("libsurfaceflinger_ddmconnection.so", RTLD_NOW); 267463f165fd6b86d04be94d4023e845e98560504a96Keun young Park if (!libddmconnection_dso) { 267563f165fd6b86d04be94d4023e845e98560504a96Keun young Park return false; 267663f165fd6b86d04be94d4023e845e98560504a96Keun young Park } 267763f165fd6b86d04be94d4023e845e98560504a96Keun young Park void (*DdmConnection_start)(const char* name); 267863f165fd6b86d04be94d4023e845e98560504a96Keun young Park DdmConnection_start = 267924cd98eef88ac93f80c327f8d74f0a1ae0aceee4Jesse Hall (decltype(DdmConnection_start))dlsym(libddmconnection_dso, "DdmConnection_start"); 268063f165fd6b86d04be94d4023e845e98560504a96Keun young Park if (!DdmConnection_start) { 268163f165fd6b86d04be94d4023e845e98560504a96Keun young Park dlclose(libddmconnection_dso); 268263f165fd6b86d04be94d4023e845e98560504a96Keun young Park return false; 268363f165fd6b86d04be94d4023e845e98560504a96Keun young Park } 268463f165fd6b86d04be94d4023e845e98560504a96Keun young Park (*DdmConnection_start)(getServiceName()); 268563f165fd6b86d04be94d4023e845e98560504a96Keun young Park return true; 268663f165fd6b86d04be94d4023e845e98560504a96Keun young Park} 268763f165fd6b86d04be94d4023e845e98560504a96Keun young Park 2688edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Projectstatus_t SurfaceFlinger::onTransact( 2689edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 2690edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 2691edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project switch (code) { 2692edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project case CREATE_CONNECTION: 2693041a075262ef5fc886e46fd4eec3dd79ee2e60c0Mathias Agopian case CREATE_DISPLAY: 2694698c0873cf2e07bdc7fd1e72169aee2a19fa40d7Mathias Agopian case SET_TRANSACTION_STATE: 2695edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project case BOOT_FINISHED: 2696d85084b2b65828442eafaff9b811e9b6c9ca9fadSvetoslav case CLEAR_ANIMATION_FRAME_STATS: 2697d85084b2b65828442eafaff9b811e9b6c9ca9fadSvetoslav case GET_ANIMATION_FRAME_STATS: 26982c9b11f0291210c9b9513a1a0cce6afebd361b3bPrashant Malani case SET_POWER_MODE: 2699edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project { 2700edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project // codes that require permission check 2701edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project IPCThreadState* ipc = IPCThreadState::self(); 2702edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project const int pid = ipc->getCallingPid(); 2703a1ecca920e15ce04fe56ebf4f1b52ba711f9eb2dMathias Agopian const int uid = ipc->getCallingUid(); 270499b49840d309727678b77403d6cc9f920111623fMathias Agopian if ((uid != AID_GRAPHICS) && 270599b49840d309727678b77403d6cc9f920111623fMathias Agopian !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)) { 2706e6f43ddce78d6846af12550ff9193c5c6fe5844bSteve Block ALOGE("Permission Denial: " 2707375f56363a8737119ce2222dcfaacbe1cf733fc0Mathias Agopian "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid); 2708375f56363a8737119ce2222dcfaacbe1cf733fc0Mathias Agopian return PERMISSION_DENIED; 2709edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 27101b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian break; 27111b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian } 27121b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian case CAPTURE_SCREEN: 27131b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian { 27141b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian // codes that require permission check 27151b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian IPCThreadState* ipc = IPCThreadState::self(); 27161b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian const int pid = ipc->getCallingPid(); 27171b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian const int uid = ipc->getCallingUid(); 271899b49840d309727678b77403d6cc9f920111623fMathias Agopian if ((uid != AID_GRAPHICS) && 271999b49840d309727678b77403d6cc9f920111623fMathias Agopian !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) { 2720e6f43ddce78d6846af12550ff9193c5c6fe5844bSteve Block ALOGE("Permission Denial: " 27211b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian "can't read framebuffer pid=%d, uid=%d", pid, uid); 27221b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian return PERMISSION_DENIED; 27231b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian } 27241b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian break; 2725edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 2726edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 27271b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian 2728edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags); 2729edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) { 2730b8a5560e1303cb10f5cd482af466fc04d2bdfcabMathias Agopian CHECK_INTERFACE(ISurfaceComposer, data, reply); 273199ed22412db547c59d3da08114d9d5a586442b30Glenn Kasten if (CC_UNLIKELY(!PermissionCache::checkCallingPermission(sHardwareTest))) { 2732375f56363a8737119ce2222dcfaacbe1cf733fc0Mathias Agopian IPCThreadState* ipc = IPCThreadState::self(); 2733375f56363a8737119ce2222dcfaacbe1cf733fc0Mathias Agopian const int pid = ipc->getCallingPid(); 2734375f56363a8737119ce2222dcfaacbe1cf733fc0Mathias Agopian const int uid = ipc->getCallingUid(); 2735e6f43ddce78d6846af12550ff9193c5c6fe5844bSteve Block ALOGE("Permission Denial: " 2736375f56363a8737119ce2222dcfaacbe1cf733fc0Mathias Agopian "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid); 2737edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project return PERMISSION_DENIED; 2738edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 2739edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project int n; 2740edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project switch (code) { 274101b766839e06c32540cef100e3a7710d12cf1eefMathias Agopian case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE 274235b48d10bc9e064201d3d54d2d476314684a7a05Mathias Agopian case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE 2743edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project return NO_ERROR; 2744edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project case 1002: // SHOW_UPDATES 2745edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project n = data.readInt32(); 2746edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project mDebugRegion = n ? n : (mDebugRegion ? 0 : 1); 274753331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian invalidateHwcGeometry(); 274853331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian repaintEverything(); 2749edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project return NO_ERROR; 2750edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project case 1004:{ // repaint everything 275153331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian repaintEverything(); 2752cbb288bfe89f585bf48371bd31b2d4aafa32f32eMathias Agopian return NO_ERROR; 2753cbb288bfe89f585bf48371bd31b2d4aafa32f32eMathias Agopian } 2754cbb288bfe89f585bf48371bd31b2d4aafa32f32eMathias Agopian case 1005:{ // force transaction 2755e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian setTransactionFlags( 2756e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian eTransactionNeeded| 2757e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian eDisplayTransactionNeeded| 2758e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian eTraversalNeeded); 2759cbb288bfe89f585bf48371bd31b2d4aafa32f32eMathias Agopian return NO_ERROR; 2760edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 27614d143eed994778d37eb09bb5d452c26f12bca6e1Mathias Agopian case 1006:{ // send empty update 27624d143eed994778d37eb09bb5d452c26f12bca6e1Mathias Agopian signalRefresh(); 27634d143eed994778d37eb09bb5d452c26f12bca6e1Mathias Agopian return NO_ERROR; 27644d143eed994778d37eb09bb5d452c26f12bca6e1Mathias Agopian } 276553331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian case 1008: // toggle use of hw composer 276653331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian n = data.readInt32(); 276753331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian mDebugDisableHWC = n ? 1 : 0; 276853331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian invalidateHwcGeometry(); 276953331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian repaintEverything(); 277053331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian return NO_ERROR; 2771a45836466c301d49d8df286b5317dfa99cb83b70Mathias Agopian case 1009: // toggle use of transform hint 2772a45836466c301d49d8df286b5317dfa99cb83b70Mathias Agopian n = data.readInt32(); 2773a45836466c301d49d8df286b5317dfa99cb83b70Mathias Agopian mDebugDisableTransformHint = n ? 1 : 0; 2774a45836466c301d49d8df286b5317dfa99cb83b70Mathias Agopian invalidateHwcGeometry(); 2775a45836466c301d49d8df286b5317dfa99cb83b70Mathias Agopian repaintEverything(); 2776a45836466c301d49d8df286b5317dfa99cb83b70Mathias Agopian return NO_ERROR; 2777edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project case 1010: // interrogate. 277801b766839e06c32540cef100e3a7710d12cf1eefMathias Agopian reply->writeInt32(0); 2779edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project reply->writeInt32(0); 2780edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project reply->writeInt32(mDebugRegion); 2781b9494d5c9d44e4a59b6d510fea1665de434f3c6bMathias Agopian reply->writeInt32(0); 278212839bee29bdcc65731b4d42029cc59e2320c5c4Dianne Hackborn reply->writeInt32(mDebugDisableHWC); 2783edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project return NO_ERROR; 2784edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project case 1013: { 2785edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project Mutex::Autolock _l(mStateLock); 27864297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian sp<const DisplayDevice> hw(getDefaultDisplayDevice()); 27874297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian reply->writeInt32(hw->getPageFlipCount()); 2788ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian return NO_ERROR; 2789ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian } 2790ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian case 1014: { 2791ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian // daltonize 2792ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian n = data.readInt32(); 2793ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian switch (n % 10) { 2794ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian case 1: mDaltonizer.setType(Daltonizer::protanomaly); break; 2795ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian case 2: mDaltonizer.setType(Daltonizer::deuteranomaly); break; 2796ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian case 3: mDaltonizer.setType(Daltonizer::tritanomaly); break; 2797ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian } 2798ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian if (n >= 10) { 2799ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian mDaltonizer.setMode(Daltonizer::correction); 2800ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian } else { 2801ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian mDaltonizer.setMode(Daltonizer::simulation); 2802ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian } 2803ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian mDaltonize = n > 0; 2804ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian invalidateHwcGeometry(); 2805ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian repaintEverything(); 28069c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette return NO_ERROR; 28079c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette } 28089c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette case 1015: { 28099c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette // apply a color matrix 28109c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette n = data.readInt32(); 28119c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette mHasColorMatrix = n ? 1 : 0; 28129c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette if (n) { 28139c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette // color matrix is sent as mat3 matrix followed by vec3 28149c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette // offset, then packed into a mat4 where the last row is 28159c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette // the offset and extra values are 0 2816794c5ba973f6d107a8277f3f389cb3051c6ce5d7Alan Viverette for (size_t i = 0 ; i < 4; i++) { 2817794c5ba973f6d107a8277f3f389cb3051c6ce5d7Alan Viverette for (size_t j = 0; j < 4; j++) { 2818794c5ba973f6d107a8277f3f389cb3051c6ce5d7Alan Viverette mColorMatrix[i][j] = data.readFloat(); 2819794c5ba973f6d107a8277f3f389cb3051c6ce5d7Alan Viverette } 28209c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette } 28219c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette } else { 28229c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette mColorMatrix = mat4(); 28239c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette } 28249c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette invalidateHwcGeometry(); 28259c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette repaintEverything(); 28269c5a3335110769993d3fe997bdf1d594954d4304Alan Viverette return NO_ERROR; 2827edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 2828f52b3c88f18c0546526996c839fbce74172e11c7Ruchi Kandoi // This is an experimental interface 2829f52b3c88f18c0546526996c839fbce74172e11c7Ruchi Kandoi // Needs to be shifted to proper binder interface when we productize 2830f52b3c88f18c0546526996c839fbce74172e11c7Ruchi Kandoi case 1016: { 2831645b1f7ffb41d21a60765d1ec54ba82f14a36a59Andy McFadden n = data.readInt32(); 2832645b1f7ffb41d21a60765d1ec54ba82f14a36a59Andy McFadden mPrimaryDispSync.setRefreshSkipCount(n); 2833f52b3c88f18c0546526996c839fbce74172e11c7Ruchi Kandoi return NO_ERROR; 2834f52b3c88f18c0546526996c839fbce74172e11c7Ruchi Kandoi } 2835edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 2836edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 2837edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project return err; 2838edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 2839edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 284053331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopianvoid SurfaceFlinger::repaintEverything() { 284187baae104a3e4c2059990b01c393476065c558b0Mathias Agopian android_atomic_or(1, &mRepaintEverything); 284299ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian signalTransaction(); 284353331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian} 284453331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian 284559119e658a12279e8fff508f8773843de2d90917Mathias Agopian// --------------------------------------------------------------------------- 28462a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian// Capture screen into an IGraphiBufferProducer 28472a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian// --------------------------------------------------------------------------- 284859119e658a12279e8fff508f8773843de2d90917Mathias Agopian 28492ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian/* The code below is here to handle b/8734824 28502ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian * 28512ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian * We create a IGraphicBufferProducer wrapper that forwards all calls 2852b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall * from the surfaceflinger thread to the calling binder thread, where they 2853b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall * are executed. This allows the calling thread in the calling process to be 2854b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall * reused and not depend on having "enough" binder threads to handle the 2855b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall * requests. 28562ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian */ 28572ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopianclass GraphicProducerWrapper : public BBinder, public MessageHandler { 2858b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall /* Parts of GraphicProducerWrapper are run on two different threads, 2859b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall * communicating by sending messages via Looper but also by shared member 2860b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall * data. Coherence maintenance is subtle and in places implicit (ugh). 2861b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall * 2862b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall * Don't rely on Looper's sendMessage/handleMessage providing 2863b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall * release/acquire semantics for any data not actually in the Message. 2864b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall * Data going from surfaceflinger to binder threads needs to be 2865b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall * synchronized explicitly. 2866b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall * 2867b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall * Barrier open/wait do provide release/acquire semantics. This provides 2868b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall * implicit synchronization for data coming back from binder to 2869b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall * surfaceflinger threads. 2870b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall */ 2871b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall 28722ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian sp<IGraphicBufferProducer> impl; 28732ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian sp<Looper> looper; 28742ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian status_t result; 28752ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian bool exitPending; 28762ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian bool exitRequested; 2877b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall Barrier barrier; 28782ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian uint32_t code; 28792ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian Parcel const* data; 28802ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian Parcel* reply; 28812ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian 28822ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian enum { 28832ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian MSG_API_CALL, 28842ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian MSG_EXIT 28852ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian }; 28862ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian 28872ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian /* 2888b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall * Called on surfaceflinger thread. This is called by our "fake" 2889b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall * BpGraphicBufferProducer. We package the data and reply Parcel and 2890b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall * forward them to the binder thread. 28912ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian */ 28922ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian virtual status_t transact(uint32_t code, 2893c701401f8cec2e5309f8b57e2b97baced5093274Dan Stoza const Parcel& data, Parcel* reply, uint32_t /* flags */) { 28942ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian this->code = code; 28952ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian this->data = &data; 28962ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian this->reply = reply; 28972ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian if (exitPending) { 2898b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall // if we've exited, we run the message synchronously right here. 2899b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall // note (JH): as far as I can tell from looking at the code, this 2900b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall // never actually happens. if it does, i'm not sure if it happens 2901b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall // on the surfaceflinger or binder thread. 29022ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian handleMessage(Message(MSG_API_CALL)); 29032ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian } else { 29042ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian barrier.close(); 2905b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall // Prevent stores to this->{code, data, reply} from being 2906b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall // reordered later than the construction of Message. 2907b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall atomic_thread_fence(memory_order_release); 29082ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian looper->sendMessage(this, Message(MSG_API_CALL)); 29092ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian barrier.wait(); 29102ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian } 2911c2633ce19bdbca4cbf8d6a225ede68a0afd693b9bdeng return result; 29122ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian } 29132ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian 29142ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian /* 2915b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall * here we run on the binder thread. All we've got to do is 29162ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian * call the real BpGraphicBufferProducer. 29172ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian */ 29182ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian virtual void handleMessage(const Message& message) { 2919b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall int what = message.what; 2920b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall // Prevent reads below from happening before the read from Message 2921b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall atomic_thread_fence(memory_order_acquire); 2922b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall if (what == MSG_API_CALL) { 2923097ca275f4717a2c47a5d49f302ed2b72c8a1370Marco Nelissen result = IInterface::asBinder(impl)->transact(code, data[0], reply); 29242ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian barrier.open(); 2925b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall } else if (what == MSG_EXIT) { 29262ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian exitRequested = true; 29272ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian } 29282ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian } 29292ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian 29302ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopianpublic: 2931b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall GraphicProducerWrapper(const sp<IGraphicBufferProducer>& impl) 2932b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall : impl(impl), 2933b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall looper(new Looper(true)), 2934b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall exitPending(false), 2935b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall exitRequested(false) 2936b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall {} 2937b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall 2938b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall // Binder thread 29392ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian status_t waitForResponse() { 29402ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian do { 29412ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian looper->pollOnce(-1); 29422ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian } while (!exitRequested); 29432ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian return result; 29442ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian } 29452ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian 2946b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall // Client thread 29472ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian void exit(status_t result) { 2948aaff4ef717c08f6aed7ccd96e1d65222ceb4fd17Mike J. Chen this->result = result; 29492ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian exitPending = true; 2950b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall // Ensure this->result is visible to the binder thread before it 2951b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall // handles the message. 2952b154c42c39c1499c26d88fff8ca642cd86f91098Jesse Hall atomic_thread_fence(memory_order_release); 29532ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian looper->sendMessage(this, Message(MSG_EXIT)); 29542ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian } 29552ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian}; 29562ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian 29572ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian 29582a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopianstatus_t SurfaceFlinger::captureScreen(const sp<IBinder>& display, 29592a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian const sp<IGraphicBufferProducer>& producer, 2960c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight, 2961c701401f8cec2e5309f8b57e2b97baced5093274Dan Stoza uint32_t minLayerZ, uint32_t maxLayerZ, 2962c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews bool useIdentityTransform, ISurfaceComposer::Rotation rotation) { 29632a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian 29642a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian if (CC_UNLIKELY(display == 0)) 29652a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian return BAD_VALUE; 29662a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian 29672a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian if (CC_UNLIKELY(producer == 0)) 29682a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian return BAD_VALUE; 29692a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian 29705ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian // if we have secure windows on this display, never allow the screen capture 29715ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian // unless the producer interface is local (i.e.: we can take a screenshot for 29725ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian // ourselves). 2973097ca275f4717a2c47a5d49f302ed2b72c8a1370Marco Nelissen if (!IInterface::asBinder(producer)->localBinder()) { 29745ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian Mutex::Autolock _l(mStateLock); 29755ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian sp<const DisplayDevice> hw(getDisplayDevice(display)); 29765ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian if (hw->getSecureLayerVisible()) { 29775ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian ALOGW("FB is protected: PERMISSION_DENIED"); 29785ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian return PERMISSION_DENIED; 29795ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian } 29805ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian } 29815ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian 2982c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews // Convert to surfaceflinger's internal rotation type. 2983c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews Transform::orientation_flags rotationFlags; 2984c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews switch (rotation) { 2985c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews case ISurfaceComposer::eRotateNone: 2986c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews rotationFlags = Transform::ROT_0; 2987c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews break; 2988c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews case ISurfaceComposer::eRotate90: 2989c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews rotationFlags = Transform::ROT_90; 2990c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews break; 2991c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews case ISurfaceComposer::eRotate180: 2992c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews rotationFlags = Transform::ROT_180; 2993c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews break; 2994c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews case ISurfaceComposer::eRotate270: 2995c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews rotationFlags = Transform::ROT_270; 2996c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews break; 2997c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews default: 2998c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews rotationFlags = Transform::ROT_0; 2999c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews ALOGE("Invalid rotation passed to captureScreen(): %d\n", rotation); 3000c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews break; 3001c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews } 3002c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews 30032a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian class MessageCaptureScreen : public MessageBase { 30042a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian SurfaceFlinger* flinger; 30052a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian sp<IBinder> display; 30062a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian sp<IGraphicBufferProducer> producer; 3007c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza Rect sourceCrop; 30082a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian uint32_t reqWidth, reqHeight; 30092a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian uint32_t minLayerZ,maxLayerZ; 3010c701401f8cec2e5309f8b57e2b97baced5093274Dan Stoza bool useIdentityTransform; 3011c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews Transform::orientation_flags rotation; 30122a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian status_t result; 30132a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian public: 30142a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian MessageCaptureScreen(SurfaceFlinger* flinger, 30152a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian const sp<IBinder>& display, 30162a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian const sp<IGraphicBufferProducer>& producer, 3017c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight, 3018c701401f8cec2e5309f8b57e2b97baced5093274Dan Stoza uint32_t minLayerZ, uint32_t maxLayerZ, 3019c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews bool useIdentityTransform, Transform::orientation_flags rotation) 30202a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian : flinger(flinger), display(display), producer(producer), 3021c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza sourceCrop(sourceCrop), reqWidth(reqWidth), reqHeight(reqHeight), 30222a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian minLayerZ(minLayerZ), maxLayerZ(maxLayerZ), 3023c701401f8cec2e5309f8b57e2b97baced5093274Dan Stoza useIdentityTransform(useIdentityTransform), 3024c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews rotation(rotation), 30252a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian result(PERMISSION_DENIED) 30262a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian { 30272a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian } 30282a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian status_t getResult() const { 30292a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian return result; 30302a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian } 30312a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian virtual bool handler() { 30322a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian Mutex::Autolock _l(flinger->mStateLock); 30332a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian sp<const DisplayDevice> hw(flinger->getDisplayDevice(display)); 3034c701401f8cec2e5309f8b57e2b97baced5093274Dan Stoza result = flinger->captureScreenImplLocked(hw, producer, 3035c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ, 3036c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews useIdentityTransform, rotation); 3037097ca275f4717a2c47a5d49f302ed2b72c8a1370Marco Nelissen static_cast<GraphicProducerWrapper*>(IInterface::asBinder(producer).get())->exit(result); 30382a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian return true; 30392a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian } 30402a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian }; 30412a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian 30429eb1f0558b5fc78920602afe7bcfa3115bb1f6beMathias Agopian // make sure to process transactions before screenshots -- a transaction 30439eb1f0558b5fc78920602afe7bcfa3115bb1f6beMathias Agopian // might already be pending but scheduled for VSYNC; this guarantees we 30449eb1f0558b5fc78920602afe7bcfa3115bb1f6beMathias Agopian // will handle it before the screenshot. When VSYNC finally arrives 30459eb1f0558b5fc78920602afe7bcfa3115bb1f6beMathias Agopian // the scheduled transaction will be a no-op. If no transactions are 30469eb1f0558b5fc78920602afe7bcfa3115bb1f6beMathias Agopian // scheduled at this time, this will end-up being a no-op as well. 30479eb1f0558b5fc78920602afe7bcfa3115bb1f6beMathias Agopian mEventQueue.invalidateTransactionNow(); 30489eb1f0558b5fc78920602afe7bcfa3115bb1f6beMathias Agopian 30492ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian // this creates a "fake" BBinder which will serve as a "fake" remote 30502ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian // binder to receive the marshaled calls and forward them to the 30512ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian // real remote (a BpGraphicBufferProducer) 30522ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian sp<GraphicProducerWrapper> wrapper = new GraphicProducerWrapper(producer); 30532ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian 30542ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian // the asInterface() call below creates our "fake" BpGraphicBufferProducer 30552ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian // which does the marshaling work forwards to our "fake remote" above. 30562a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian sp<MessageBase> msg = new MessageCaptureScreen(this, 30572ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian display, IGraphicBufferProducer::asInterface( wrapper ), 3058c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ, 3059c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews useIdentityTransform, rotationFlags); 30602ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian 30612ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian status_t res = postMessageAsync(msg); 30622a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian if (res == NO_ERROR) { 30632ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian res = wrapper->waitForResponse(); 30642a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian } 30652a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian return res; 3066118d0245ee0a3b107055782aa8b555404b6f0280Mathias Agopian} 3067118d0245ee0a3b107055782aa8b555404b6f0280Mathias Agopian 3068180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 3069180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopianvoid SurfaceFlinger::renderScreenImplLocked( 3070180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian const sp<const DisplayDevice>& hw, 3071c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight, 3072180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian uint32_t minLayerZ, uint32_t maxLayerZ, 3073c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews bool yswap, bool useIdentityTransform, Transform::orientation_flags rotation) 3074180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian{ 3075180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian ATRACE_CALL(); 30763f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian RenderEngine& engine(getRenderEngine()); 3077180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 3078180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian // get screen geometry 307989fd4f7fa6bd17ce5400979c3b9e5ba0bf7e919eAndreas Gampe const int32_t hw_w = hw->getWidth(); 308089fd4f7fa6bd17ce5400979c3b9e5ba0bf7e919eAndreas Gampe const int32_t hw_h = hw->getHeight(); 308189fd4f7fa6bd17ce5400979c3b9e5ba0bf7e919eAndreas Gampe const bool filtering = static_cast<int32_t>(reqWidth) != hw_w || 308289fd4f7fa6bd17ce5400979c3b9e5ba0bf7e919eAndreas Gampe static_cast<int32_t>(reqWidth) != hw_h; 3083180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 3084c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza // if a default or invalid sourceCrop is passed in, set reasonable values 3085c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza if (sourceCrop.width() == 0 || sourceCrop.height() == 0 || 3086c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza !sourceCrop.isValid()) { 3087c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza sourceCrop.setLeftTop(Point(0, 0)); 3088c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza sourceCrop.setRightBottom(Point(hw_w, hw_h)); 3089c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza } 3090c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza 3091c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza // ensure that sourceCrop is inside screen 3092c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza if (sourceCrop.left < 0) { 3093c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza ALOGE("Invalid crop rect: l = %d (< 0)", sourceCrop.left); 3094c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza } 3095be31f447984b3ab4ac011353b6b53216b4335e04Dan Stoza if (sourceCrop.right > hw_w) { 3096be31f447984b3ab4ac011353b6b53216b4335e04Dan Stoza ALOGE("Invalid crop rect: r = %d (> %d)", sourceCrop.right, hw_w); 3097c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza } 3098c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza if (sourceCrop.top < 0) { 3099c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza ALOGE("Invalid crop rect: t = %d (< 0)", sourceCrop.top); 3100c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza } 3101be31f447984b3ab4ac011353b6b53216b4335e04Dan Stoza if (sourceCrop.bottom > hw_h) { 3102be31f447984b3ab4ac011353b6b53216b4335e04Dan Stoza ALOGE("Invalid crop rect: b = %d (> %d)", sourceCrop.bottom, hw_h); 3103c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza } 3104c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza 3105180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian // make sure to clear all GL error flags 31063f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian engine.checkErrors(); 3107180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 3108180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian // set-up our viewport 3109c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews engine.setViewportAndProjection( 3110c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews reqWidth, reqHeight, sourceCrop, hw_h, yswap, rotation); 31113f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian engine.disableTexturing(); 3112180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 3113180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian // redraw the screen entirely... 31143f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian engine.clearWithColor(0, 0, 0, 1); 3115180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 3116180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian const LayerVector& layers( mDrawingState.layersSortedByZ ); 3117180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian const size_t count = layers.size(); 3118180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian for (size_t i=0 ; i<count ; ++i) { 3119180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian const sp<Layer>& layer(layers[i]); 31201eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const Layer::State& state(layer->getDrawingState()); 3121180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian if (state.layerStack == hw->getLayerStack()) { 3122180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian if (state.z >= minLayerZ && state.z <= maxLayerZ) { 3123180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian if (layer->isVisible()) { 3124180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian if (filtering) layer->setFiltering(true); 3125c701401f8cec2e5309f8b57e2b97baced5093274Dan Stoza layer->draw(hw, useIdentityTransform); 3126180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian if (filtering) layer->setFiltering(false); 3127180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian } 3128180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian } 3129180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian } 3130180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian } 3131180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 3132180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian // compositionComplete is needed for older driver 3133180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian hw->compositionComplete(); 3134931bda1c472ba8c8e965bdba6757ff94154df903Mathias Agopian hw->setViewportAndProjection(); 3135180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian} 3136180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 3137180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 31382a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopianstatus_t SurfaceFlinger::captureScreenImplLocked( 31392a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian const sp<const DisplayDevice>& hw, 31402a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian const sp<IGraphicBufferProducer>& producer, 3141c18790018be5d7ea7061ccbc81f3044e74adc823Dan Stoza Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight, 3142c701401f8cec2e5309f8b57e2b97baced5093274Dan Stoza uint32_t minLayerZ, uint32_t maxLayerZ, 3143c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews bool useIdentityTransform, Transform::orientation_flags rotation) 314474c40c0a273dbfd7d10617c4cc1b0c066bfc812eMathias Agopian{ 3145fddc28d87136b55f0d9613e5f8ecd64a6aca018dMathias Agopian ATRACE_CALL(); 3146fddc28d87136b55f0d9613e5f8ecd64a6aca018dMathias Agopian 3147180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian // get screen geometry 3148180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian const uint32_t hw_w = hw->getWidth(); 3149180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian const uint32_t hw_h = hw->getHeight(); 3150180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 3151180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian if ((reqWidth > hw_w) || (reqHeight > hw_h)) { 3152180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian ALOGE("size mismatch (%d, %d) > (%d, %d)", 3153180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian reqWidth, reqHeight, hw_w, hw_h); 3154180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian return BAD_VALUE; 3155180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian } 3156180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 3157180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian reqWidth = (!reqWidth) ? hw_w : reqWidth; 3158180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian reqHeight = (!reqHeight) ? hw_h : reqHeight; 3159180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 31600aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian // create a surface (because we're a producer, and we need to 31610aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian // dequeue/queue a buffer) 316283cafffeac037ab2f9d00f98f8d2f3da8fc9b857Jesse Hall sp<Surface> sur = new Surface(producer, false); 31630aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian ANativeWindow* window = sur.get(); 316474c40c0a273dbfd7d10617c4cc1b0c066bfc812eMathias Agopian 31650aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian status_t result = NO_ERROR; 31660aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian if (native_window_api_connect(window, NATIVE_WINDOW_API_EGL) == NO_ERROR) { 31673ca76f416bc8665a97636ca8a2d0128b9da9d92cMathias Agopian uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN | 31683ca76f416bc8665a97636ca8a2d0128b9da9d92cMathias Agopian GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE; 31692a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian 31700aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian int err = 0; 31710aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian err = native_window_set_buffers_dimensions(window, reqWidth, reqHeight); 31724ceff3d5efd27c164788bb2b3f0fd17c691a0204Mathias Agopian err |= native_window_set_scaling_mode(window, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW); 31730aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian err |= native_window_set_buffers_format(window, HAL_PIXEL_FORMAT_RGBA_8888); 31740aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian err |= native_window_set_usage(window, usage); 31752a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian 31760aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian if (err == NO_ERROR) { 31770aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian ANativeWindowBuffer* buffer; 31780aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian /* TODO: Once we have the sync framework everywhere this can use 31790aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian * server-side waits on the fence that dequeueBuffer returns. 31800aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian */ 31810aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian result = native_window_dequeue_buffer_and_wait(window, &buffer); 31820aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian if (result == NO_ERROR) { 3183866399093f9f60e7305f291e688abb456bace710Riley Andrews int syncFd = -1; 31840aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian // create an EGLImage from the buffer so we can later 31850aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian // turn it into a texture 31860aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian EGLImageKHR image = eglCreateImageKHR(mEGLDisplay, EGL_NO_CONTEXT, 31870aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian EGL_NATIVE_BUFFER_ANDROID, buffer, NULL); 31880aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian if (image != EGL_NO_IMAGE_KHR) { 31893f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian // this binds the given EGLImage as a framebuffer for the 31903f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian // duration of this scope. 31913f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian RenderEngine::BindImageAsFramebuffer imageBond(getRenderEngine(), image); 31923f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian if (imageBond.getStatus() == NO_ERROR) { 31930aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian // this will in fact render into our dequeued buffer 31940aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian // via an FBO, which means we didn't have to create 31950aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian // an EGLSurface and therefore we're not 31960aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian // dependent on the context's EGLConfig. 3197c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews renderScreenImplLocked( 3198c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews hw, sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ, true, 3199c3ebe66b49cfba035e1fd0e160a13db38eb81b0eRiley Andrews useIdentityTransform, rotation); 3200d555684cb36dfb959694db76962e570184f98838Mathias Agopian 3201866399093f9f60e7305f291e688abb456bace710Riley Andrews // Attempt to create a sync khr object that can produce a sync point. If that 3202866399093f9f60e7305f291e688abb456bace710Riley Andrews // isn't available, create a non-dupable sync object in the fallback path and 3203866399093f9f60e7305f291e688abb456bace710Riley Andrews // wait on it directly. 3204866399093f9f60e7305f291e688abb456bace710Riley Andrews EGLSyncKHR sync; 3205866399093f9f60e7305f291e688abb456bace710Riley Andrews if (!DEBUG_SCREENSHOTS) { 3206866399093f9f60e7305f291e688abb456bace710Riley Andrews sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, NULL); 3207866399093f9f60e7305f291e688abb456bace710Riley Andrews } else { 3208866399093f9f60e7305f291e688abb456bace710Riley Andrews sync = EGL_NO_SYNC_KHR; 3209866399093f9f60e7305f291e688abb456bace710Riley Andrews } 32102d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden if (sync != EGL_NO_SYNC_KHR) { 3211866399093f9f60e7305f291e688abb456bace710Riley Andrews // get the sync fd 3212866399093f9f60e7305f291e688abb456bace710Riley Andrews syncFd = eglDupNativeFenceFDANDROID(mEGLDisplay, sync); 3213866399093f9f60e7305f291e688abb456bace710Riley Andrews if (syncFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) { 3214866399093f9f60e7305f291e688abb456bace710Riley Andrews ALOGW("captureScreen: failed to dup sync khr object"); 3215866399093f9f60e7305f291e688abb456bace710Riley Andrews syncFd = -1; 3216866399093f9f60e7305f291e688abb456bace710Riley Andrews } 32172d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden eglDestroySyncKHR(mEGLDisplay, sync); 3218866399093f9f60e7305f291e688abb456bace710Riley Andrews } else { 3219866399093f9f60e7305f291e688abb456bace710Riley Andrews // fallback path 3220866399093f9f60e7305f291e688abb456bace710Riley Andrews sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, NULL); 3221866399093f9f60e7305f291e688abb456bace710Riley Andrews if (sync != EGL_NO_SYNC_KHR) { 3222866399093f9f60e7305f291e688abb456bace710Riley Andrews EGLint result = eglClientWaitSyncKHR(mEGLDisplay, sync, 3223866399093f9f60e7305f291e688abb456bace710Riley Andrews EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, 2000000000 /*2 sec*/); 3224866399093f9f60e7305f291e688abb456bace710Riley Andrews EGLint eglErr = eglGetError(); 3225866399093f9f60e7305f291e688abb456bace710Riley Andrews if (result == EGL_TIMEOUT_EXPIRED_KHR) { 3226866399093f9f60e7305f291e688abb456bace710Riley Andrews ALOGW("captureScreen: fence wait timed out"); 3227866399093f9f60e7305f291e688abb456bace710Riley Andrews } else { 3228866399093f9f60e7305f291e688abb456bace710Riley Andrews ALOGW_IF(eglErr != EGL_SUCCESS, 3229866399093f9f60e7305f291e688abb456bace710Riley Andrews "captureScreen: error waiting on EGL fence: %#x", eglErr); 3230866399093f9f60e7305f291e688abb456bace710Riley Andrews } 3231866399093f9f60e7305f291e688abb456bace710Riley Andrews eglDestroySyncKHR(mEGLDisplay, sync); 32322d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden } else { 3233866399093f9f60e7305f291e688abb456bace710Riley Andrews ALOGW("captureScreen: error creating EGL fence: %#x", eglGetError()); 32342d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden } 32352d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden } 3236d555684cb36dfb959694db76962e570184f98838Mathias Agopian if (DEBUG_SCREENSHOTS) { 3237d555684cb36dfb959694db76962e570184f98838Mathias Agopian uint32_t* pixels = new uint32_t[reqWidth*reqHeight]; 3238d555684cb36dfb959694db76962e570184f98838Mathias Agopian getRenderEngine().readPixels(0, 0, reqWidth, reqHeight, pixels); 3239d555684cb36dfb959694db76962e570184f98838Mathias Agopian checkScreenshot(reqWidth, reqHeight, reqWidth, pixels, 3240d555684cb36dfb959694db76962e570184f98838Mathias Agopian hw, minLayerZ, maxLayerZ); 3241d555684cb36dfb959694db76962e570184f98838Mathias Agopian delete [] pixels; 3242d555684cb36dfb959694db76962e570184f98838Mathias Agopian } 3243d555684cb36dfb959694db76962e570184f98838Mathias Agopian 32440aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian } else { 32450aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian ALOGE("got GL_FRAMEBUFFER_COMPLETE_OES error while taking screenshot"); 32460aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian result = INVALID_OPERATION; 32470aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian } 32480aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian // destroy our image 32490aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian eglDestroyImageKHR(mEGLDisplay, image); 32500aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian } else { 32510aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian result = BAD_VALUE; 325274c40c0a273dbfd7d10617c4cc1b0c066bfc812eMathias Agopian } 3253866399093f9f60e7305f291e688abb456bace710Riley Andrews window->queueBuffer(window, buffer, syncFd); 3254866399093f9f60e7305f291e688abb456bace710Riley Andrews if (syncFd != -1) { 3255866399093f9f60e7305f291e688abb456bace710Riley Andrews close(syncFd); 3256866399093f9f60e7305f291e688abb456bace710Riley Andrews } 325774c40c0a273dbfd7d10617c4cc1b0c066bfc812eMathias Agopian } 32580aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian } else { 32590aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian result = BAD_VALUE; 326074c40c0a273dbfd7d10617c4cc1b0c066bfc812eMathias Agopian } 32610aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL); 326274c40c0a273dbfd7d10617c4cc1b0c066bfc812eMathias Agopian } 326374c40c0a273dbfd7d10617c4cc1b0c066bfc812eMathias Agopian 326474c40c0a273dbfd7d10617c4cc1b0c066bfc812eMathias Agopian return result; 326574c40c0a273dbfd7d10617c4cc1b0c066bfc812eMathias Agopian} 326674c40c0a273dbfd7d10617c4cc1b0c066bfc812eMathias Agopian 3267d555684cb36dfb959694db76962e570184f98838Mathias Agopianvoid SurfaceFlinger::checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr, 3268d555684cb36dfb959694db76962e570184f98838Mathias Agopian const sp<const DisplayDevice>& hw, uint32_t minLayerZ, uint32_t maxLayerZ) { 3269fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian if (DEBUG_SCREENSHOTS) { 3270d555684cb36dfb959694db76962e570184f98838Mathias Agopian for (size_t y=0 ; y<h ; y++) { 3271d555684cb36dfb959694db76962e570184f98838Mathias Agopian uint32_t const * p = (uint32_t const *)vaddr + y*s; 3272d555684cb36dfb959694db76962e570184f98838Mathias Agopian for (size_t x=0 ; x<w ; x++) { 3273fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian if (p[x] != 0xFF000000) return; 3274fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian } 3275fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian } 3276fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian ALOGE("*** we just took a black screenshot ***\n" 3277fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian "requested minz=%d, maxz=%d, layerStack=%d", 3278fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian minLayerZ, maxLayerZ, hw->getLayerStack()); 3279fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian const LayerVector& layers( mDrawingState.layersSortedByZ ); 3280fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian const size_t count = layers.size(); 3281fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian for (size_t i=0 ; i<count ; ++i) { 3282fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian const sp<Layer>& layer(layers[i]); 3283fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian const Layer::State& state(layer->getDrawingState()); 3284fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian const bool visible = (state.layerStack == hw->getLayerStack()) 3285fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian && (state.z >= minLayerZ && state.z <= maxLayerZ) 3286fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian && (layer->isVisible()); 328786efcc0cbc1d94250b72ef1f2ea8700a04cd2781Greg Hackmann ALOGE("%c index=%zu, name=%s, layerStack=%d, z=%d, visible=%d, flags=%x, alpha=%x", 3288fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian visible ? '+' : '-', 3289fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian i, layer->getName().string(), state.layerStack, state.z, 3290fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian layer->isVisible(), state.flags, state.alpha); 3291fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian } 3292fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian } 3293fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian} 3294fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian 32951b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian// --------------------------------------------------------------------------- 32961b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian 3297921e6ac4b7610a178285898d191eb0e3afe906c0Mathias AgopianSurfaceFlinger::LayerVector::LayerVector() { 3298921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian} 3299921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian 3300921e6ac4b7610a178285898d191eb0e3afe906c0Mathias AgopianSurfaceFlinger::LayerVector::LayerVector(const LayerVector& rhs) 330113127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian : SortedVector<sp<Layer> >(rhs) { 3302921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian} 3303921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian 3304921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopianint SurfaceFlinger::LayerVector::do_compare(const void* lhs, 3305921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian const void* rhs) const 3306edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 3307be246f86bd6378a5110e81e9d9068ab03c3b077eMathias Agopian // sort layers per layer-stack, then by z-order and finally by sequence 330813127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& l(*reinterpret_cast<const sp<Layer>*>(lhs)); 330913127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& r(*reinterpret_cast<const sp<Layer>*>(rhs)); 3310be246f86bd6378a5110e81e9d9068ab03c3b077eMathias Agopian 33111eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian uint32_t ls = l->getCurrentState().layerStack; 33121eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian uint32_t rs = r->getCurrentState().layerStack; 3313be246f86bd6378a5110e81e9d9068ab03c3b077eMathias Agopian if (ls != rs) 3314be246f86bd6378a5110e81e9d9068ab03c3b077eMathias Agopian return ls - rs; 3315be246f86bd6378a5110e81e9d9068ab03c3b077eMathias Agopian 33161eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian uint32_t lz = l->getCurrentState().z; 33171eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian uint32_t rz = r->getCurrentState().z; 3318be246f86bd6378a5110e81e9d9068ab03c3b077eMathias Agopian if (lz != rz) 3319be246f86bd6378a5110e81e9d9068ab03c3b077eMathias Agopian return lz - rz; 3320be246f86bd6378a5110e81e9d9068ab03c3b077eMathias Agopian 3321be246f86bd6378a5110e81e9d9068ab03c3b077eMathias Agopian return l->sequence - r->sequence; 3322921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian} 3323921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian 3324921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian// --------------------------------------------------------------------------- 3325921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian 33263ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias AgopianSurfaceFlinger::DisplayDeviceState::DisplayDeviceState() 332747e45405d1533aa73307014f7bf371e118695cf3Michael Lentine : type(DisplayDevice::DISPLAY_ID_INVALID), width(0), height(0) { 3328e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian} 3329e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian 33303ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias AgopianSurfaceFlinger::DisplayDeviceState::DisplayDeviceState(DisplayDevice::DisplayType type) 333147e45405d1533aa73307014f7bf371e118695cf3Michael Lentine : type(type), layerStack(DisplayDevice::NO_LAYER_STACK), orientation(0), width(0), height(0) { 3332da8d0a5c0cf9d41915d3b106cad4aaec3e767c11Mathias Agopian viewport.makeInvalid(); 3333da8d0a5c0cf9d41915d3b106cad4aaec3e767c11Mathias Agopian frame.makeInvalid(); 3334b7e930db175c192464cebdeb49eb56cf6dd60114Mathias Agopian} 33357303c6bf1a8b00a0e7d8165d774a1f259b4ccda9Mathias Agopian 3336b7e930db175c192464cebdeb49eb56cf6dd60114Mathias Agopian// --------------------------------------------------------------------------- 333796f0819f81293076e652792794a961543e6750d7Mathias Agopian 3338edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project}; // namespace android 33393f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian 33403f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian 33413f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian#if defined(__gl_h_) 33423f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian#error "don't include gl/gl.h in this file" 33433f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian#endif 33443f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian 33453f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian#if defined(__gl2_h_) 33463f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian#error "don't include gl2/gl2.h in this file" 33473f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian#endif 3348