SurfaceFlinger.cpp revision 948fe0ce74c13e1bbff233883c158519fa8fb293
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> 24921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian 25921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian#include <EGL/egl.h> 26edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 27edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#include <cutils/log.h> 28edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#include <cutils/properties.h> 29edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 30c5b2c0bf8007562536b822eb060fc54a01f8e08bMathias Agopian#include <binder/IPCThreadState.h> 31c5b2c0bf8007562536b822eb060fc54a01f8e08bMathias Agopian#include <binder/IServiceManager.h> 327303c6bf1a8b00a0e7d8165d774a1f259b4ccda9Mathias Agopian#include <binder/MemoryHeapBase.h> 3399b49840d309727678b77403d6cc9f920111623fMathias Agopian#include <binder/PermissionCache.h> 347303c6bf1a8b00a0e7d8165d774a1f259b4ccda9Mathias Agopian 35c666cae2d5995097ec49a87e375e2afdd92802b7Mathias Agopian#include <ui/DisplayInfo.h> 36c666cae2d5995097ec49a87e375e2afdd92802b7Mathias Agopian 37921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian#include <gui/BitTube.h> 381a4d883dcc1725892bfb5c28dec255a233186524Jamie Gennis#include <gui/BufferQueue.h> 394803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden#include <gui/GuiConfig.h> 401a4d883dcc1725892bfb5c28dec255a233186524Jamie Gennis#include <gui/IDisplayEventConnection.h> 41e3c697fb929c856b59fa56a8e05a2a7eba187c3dMathias Agopian#include <gui/Surface.h> 42392edd88cb63d71a21a86a02cf9c56ac97637128Jamie Gennis#include <gui/GraphicBufferAlloc.h> 43921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian 44921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian#include <ui/GraphicBufferAllocator.h> 45921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian#include <ui/PixelFormat.h> 464803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden#include <ui/UiConfig.h> 47d0566bc26fcf6ca396118701fa11900b627f2c09Mathias Agopian 48cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian#include <utils/misc.h> 49edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#include <utils/String8.h> 50edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#include <utils/String16.h> 51edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#include <utils/StopWatch.h> 521c8e95cf86f2182986385bc1ee85f13f425f3a3aJamie Gennis#include <utils/Trace.h> 53edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 54921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian#include <private/android_filesystem_config.h> 55ca08833d5ea99130797e10ad68a651b50e99da74Mathias Agopian#include <private/gui/SyncFeatures.h> 56edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 573e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian#include "Client.h" 58edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#include "clz.h" 593e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian#include "Colorizer.h" 6090ac799241f077a7b7e6c1875fd933864c8dd2a7Mathias Agopian#include "DdmConnection.h" 610f2f5ff75b7b48ceb64270655ee6b62d09bf4d00Mathias Agopian#include "DisplayDevice.h" 62faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis#include "DispSync.h" 63d0566bc26fcf6ca396118701fa11900b627f2c09Mathias Agopian#include "EventThread.h" 64edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#include "Layer.h" 65edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#include "LayerDim.h" 66edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#include "SurfaceFlinger.h" 67edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 68a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian#include "DisplayHardware/FramebufferSurface.h" 69a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian#include "DisplayHardware/HWComposer.h" 7099c7dbb24994df2f3e175f7b25dd2c9dd92a72f0Jesse Hall#include "DisplayHardware/VirtualDisplaySurface.h" 71edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 72ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian#include "Effects/Daltonizer.h" 73ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian 74875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian#include "RenderEngine/RenderEngine.h" 75ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian#include <cutils/compiler.h> 76875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian 77edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project#define DISPLAY_COUNT 1 78edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 79fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian/* 80fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian * DEBUG_SCREENSHOTS: set to true to check that screenshots are not all 81fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian * black pixels. 82fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian */ 83fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian#define DEBUG_SCREENSHOTS false 84fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian 85ca08833d5ea99130797e10ad68a651b50e99da74Mathias AgopianEGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name); 86ca08833d5ea99130797e10ad68a651b50e99da74Mathias Agopian 87edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Projectnamespace android { 88faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 89faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// This works around the lack of support for the sync framework on some 90faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// devices. 91faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis#ifdef RUNNING_WITHOUT_SYNC_FRAMEWORK 92faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennisstatic const bool runningWithoutSyncFramework = true; 93faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis#else 94faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennisstatic const bool runningWithoutSyncFramework = false; 95faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis#endif 96faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 97faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// This is the phase offset in nanoseconds of the software vsync event 98faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// relative to the vsync event reported by HWComposer. The software vsync 99faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// event is when SurfaceFlinger and Choreographer-based applications run each 100faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// frame. 101faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// 102faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// This phase offset allows adjustment of the minimum latency from application 103faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// wake-up (by Choregographer) time to the time at which the resulting window 104faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// image is displayed. This value may be either positive (after the HW vsync) 105faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// or negative (before the HW vsync). Setting it to 0 will result in a 106faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// minimum latency of two vsync periods because the app and SurfaceFlinger 107faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// will run just after the HW vsync. Setting it to a positive number will 108faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// result in the minimum latency being: 109faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// 110faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// (2 * VSYNC_PERIOD - (vsyncPhaseOffsetNs % VSYNC_PERIOD)) 111faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// 112faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// Note that reducing this latency makes it more likely for the applications 113faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// to not have their window content image ready in time. When this happens 114faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// the latency will end up being an additional vsync period, and animations 115faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// will hiccup. Therefore, this latency should be tuned somewhat 116faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis// conservatively (or at least with awareness of the trade-off being made). 117faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennisstatic const int64_t vsyncPhaseOffsetNs = VSYNC_EVENT_PHASE_OFFSET_NS; 118faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 119edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project// --------------------------------------------------------------------------- 120edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 12199b49840d309727678b77403d6cc9f920111623fMathias Agopianconst String16 sHardwareTest("android.permission.HARDWARE_TEST"); 12299b49840d309727678b77403d6cc9f920111623fMathias Agopianconst String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER"); 12399b49840d309727678b77403d6cc9f920111623fMathias Agopianconst String16 sReadFramebuffer("android.permission.READ_FRAME_BUFFER"); 12499b49840d309727678b77403d6cc9f920111623fMathias Agopianconst String16 sDump("android.permission.DUMP"); 12599b49840d309727678b77403d6cc9f920111623fMathias Agopian 12699b49840d309727678b77403d6cc9f920111623fMathias Agopian// --------------------------------------------------------------------------- 12799b49840d309727678b77403d6cc9f920111623fMathias Agopian 128edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source ProjectSurfaceFlinger::SurfaceFlinger() 1294f4f0943489d9113c66ac22b58cfba8c21dfa879Mathias Agopian : BnSurfaceComposer(), 130edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project mTransactionFlags(0), 1312d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis mTransactionPending(false), 1322d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis mAnimTransactionPending(false), 133076b1cc3a9b90aa5b381a1ed268ca0b548444c9bMathias Agopian mLayersRemoved(false), 13452bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian mRepaintEverything(0), 135875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian mRenderEngine(NULL), 136edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project mBootTime(systemTime()), 137edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project mVisibleRegionsDirty(false), 138a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian mHwWorkListDirty(false), 1394b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis mAnimCompositionPending(false), 140edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project mDebugRegion(0), 1418afb7e39a83a3e31170612d562eb08508e328388Mathias Agopian mDebugDDMS(0), 14273d3ba9e50be1014aa21ec4bbdc874be394accb4Mathias Agopian mDebugDisableHWC(0), 143a45836466c301d49d8df286b5317dfa99cb83b70Mathias Agopian mDebugDisableTransformHint(0), 1449795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian mDebugInSwapBuffers(0), 1459795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian mLastSwapBufferTime(0), 1469795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian mDebugInTransaction(0), 1479795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian mLastTransactionTime(0), 148ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian mBootFinished(false), 149faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mPrimaryHWVsyncEnabled(false), 150948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall mHWVsyncAvailable(false), 151ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian mDaltonize(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 18899ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopianvoid 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 317722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopianstatus_t SurfaceFlinger::selectConfigForAttribute( 318a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian EGLDisplay dpy, 319a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian EGLint const* attrs, 320722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian EGLint attribute, EGLint wanted, 321a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian EGLConfig* outConfig) 322a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian{ 323a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian EGLConfig config = NULL; 324a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian EGLint numConfigs = -1, n=0; 325a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian eglGetConfigs(dpy, NULL, 0, &numConfigs); 326a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian EGLConfig* const configs = new EGLConfig[numConfigs]; 327a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian eglChooseConfig(dpy, attrs, configs, numConfigs, &n); 328cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian 329722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian if (n) { 330722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian if (attribute != EGL_NONE) { 331722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian for (int i=0 ; i<n ; i++) { 332722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian EGLint value = 0; 333722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian eglGetConfigAttrib(dpy, configs[i], attribute, &value); 334722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian if (wanted == value) { 335722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian *outConfig = configs[i]; 336722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian delete [] configs; 337722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian return NO_ERROR; 338722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian } 339722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian } 340722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian } else { 341722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian // just pick the first one 342722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian *outConfig = configs[0]; 343a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian delete [] configs; 344a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian return NO_ERROR; 345a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian } 346a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian } 347a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian delete [] configs; 348a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian return NAME_NOT_FOUND; 349edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 350edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 351722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopianclass EGLAttributeVector { 352722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian struct Attribute; 353722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian class Adder; 354722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian friend class Adder; 355722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian KeyedVector<Attribute, EGLint> mList; 356722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian struct Attribute { 357722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian Attribute() {}; 358722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian Attribute(EGLint v) : v(v) { } 359722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian EGLint v; 360722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian bool operator < (const Attribute& other) const { 361722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian // this places EGL_NONE at the end 362722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian EGLint lhs(v); 363722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian EGLint rhs(other.v); 364722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian if (lhs == EGL_NONE) lhs = 0x7FFFFFFF; 365722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian if (rhs == EGL_NONE) rhs = 0x7FFFFFFF; 366722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian return lhs < rhs; 367722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian } 368722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian }; 369722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian class Adder { 370722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian friend class EGLAttributeVector; 371722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian EGLAttributeVector& v; 372722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian EGLint attribute; 373722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian Adder(EGLAttributeVector& v, EGLint attribute) 374722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian : v(v), attribute(attribute) { 375722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian } 376722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian public: 377722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian void operator = (EGLint value) { 378722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian if (attribute != EGL_NONE) { 379722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian v.mList.add(attribute, value); 380722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian } 381722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian } 382722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian operator EGLint () const { return v.mList[attribute]; } 383722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian }; 384722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopianpublic: 385722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian EGLAttributeVector() { 386722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian mList.add(EGL_NONE, EGL_NONE); 387722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian } 388722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian void remove(EGLint attribute) { 389722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian if (attribute != EGL_NONE) { 390722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian mList.removeItem(attribute); 391722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian } 392722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian } 393722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian Adder operator [] (EGLint attribute) { 394722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian return Adder(*this, attribute); 395722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian } 396722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian EGLint operator [] (EGLint attribute) const { 397722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian return mList[attribute]; 398722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian } 399722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian // cast-operator to (EGLint const*) 400722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian operator EGLint const* () const { return &mList.keyAt(0).v; } 401722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian}; 402722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian 403b65f32ebe2c86869b07ac1c986660dfb2187b7d3Jesse Hallstatus_t SurfaceFlinger::selectEGLConfig(EGLDisplay display, EGLint nativeVisualId, 404b65f32ebe2c86869b07ac1c986660dfb2187b7d3Jesse Hall EGLint renderableType, EGLConfig* config) { 405a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian // select our EGLConfig. It must support EGL_RECORDABLE_ANDROID if 406a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian // it is to be used with WIFI displays 407a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian status_t err; 4082185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian EGLint wantedAttribute; 4092185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian EGLint wantedAttributeValue; 410da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian 411722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian EGLAttributeVector attribs; 4122185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian if (renderableType) { 4132185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian attribs[EGL_RENDERABLE_TYPE] = renderableType; 4142185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian attribs[EGL_RECORDABLE_ANDROID] = EGL_TRUE; 4152185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian attribs[EGL_SURFACE_TYPE] = EGL_WINDOW_BIT|EGL_PBUFFER_BIT; 4162185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian attribs[EGL_FRAMEBUFFER_TARGET_ANDROID] = EGL_TRUE; 4172185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian attribs[EGL_RED_SIZE] = 8; 4182185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian attribs[EGL_GREEN_SIZE] = 8; 4192185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian attribs[EGL_BLUE_SIZE] = 8; 4202185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian wantedAttribute = EGL_NONE; 4212185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian wantedAttributeValue = EGL_NONE; 4222185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian 4232185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian } else { 4242185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian // if no renderable type specified, fallback to a simplified query 4252185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian wantedAttribute = EGL_NATIVE_VISUAL_ID; 4262185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian wantedAttributeValue = nativeVisualId; 4272185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian } 428722b98f9dfe8f04de8734630198b99a6cd024118Mathias Agopian 4292185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian err = selectConfigForAttribute(display, attribs, wantedAttribute, 430b65f32ebe2c86869b07ac1c986660dfb2187b7d3Jesse Hall wantedAttributeValue, config); 431b65f32ebe2c86869b07ac1c986660dfb2187b7d3Jesse Hall if (err == NO_ERROR) { 432b65f32ebe2c86869b07ac1c986660dfb2187b7d3Jesse Hall EGLint caveat; 433b65f32ebe2c86869b07ac1c986660dfb2187b7d3Jesse Hall if (eglGetConfigAttrib(display, *config, EGL_CONFIG_CAVEAT, &caveat)) 434b65f32ebe2c86869b07ac1c986660dfb2187b7d3Jesse Hall ALOGW_IF(caveat == EGL_SLOW_CONFIG, "EGL_SLOW_CONFIG selected!"); 435b65f32ebe2c86869b07ac1c986660dfb2187b7d3Jesse Hall } 436b65f32ebe2c86869b07ac1c986660dfb2187b7d3Jesse Hall return err; 437a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian} 438edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 439faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennisclass DispSyncSource : public VSyncSource, private DispSync::Callback { 440faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennispublic: 441faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis DispSyncSource(DispSync* dispSync) : mValue(0), mDispSync(dispSync) {} 442faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 443faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis virtual ~DispSyncSource() {} 444faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 445faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis virtual void setVSyncEnabled(bool enable) { 446faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis // Do NOT lock the mutex here so as to avoid any mutex ordering issues 447faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis // with locking it in the onDispSyncEvent callback. 448faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (enable) { 449faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis status_t err = mDispSync->addEventListener(vsyncPhaseOffsetNs, 450faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis static_cast<DispSync::Callback*>(this)); 451faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (err != NO_ERROR) { 452faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis ALOGE("error registering vsync callback: %s (%d)", 453faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis strerror(-err), err); 454faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 455faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis ATRACE_INT("VsyncOn", 1); 456faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } else { 457faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis status_t err = mDispSync->removeEventListener( 458faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis static_cast<DispSync::Callback*>(this)); 459faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (err != NO_ERROR) { 460faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis ALOGE("error unregistering vsync callback: %s (%d)", 461faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis strerror(-err), err); 462faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 463faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis ATRACE_INT("VsyncOn", 0); 464faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 465faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 466faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 467faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis virtual void setCallback(const sp<VSyncSource::Callback>& callback) { 468faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis Mutex::Autolock lock(mMutex); 469faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mCallback = callback; 470faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 471faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 472faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennisprivate: 473faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis virtual void onDispSyncEvent(nsecs_t when) { 474faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis sp<VSyncSource::Callback> callback; 475faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis { 476faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis Mutex::Autolock lock(mMutex); 477faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis callback = mCallback; 478a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian 479faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mValue = (mValue + 1) % 2; 480faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis ATRACE_INT("VSYNC", mValue); 481faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 482faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 483faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (callback != NULL) { 484faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis callback->onVSyncEvent(when); 485faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 486faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 487faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 488faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis int mValue; 489faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 490faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis DispSync* mDispSync; 491faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis sp<VSyncSource::Callback> mCallback; 492faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis Mutex mMutex; 493faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis}; 494faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 495faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennisvoid SurfaceFlinger::init() { 496a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian ALOGI( "SurfaceFlinger's main thread ready to run. " 497a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian "Initializing graphics H/W..."); 498a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian 499b65f32ebe2c86869b07ac1c986660dfb2187b7d3Jesse Hall status_t err; 500692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall Mutex::Autolock _l(mStateLock); 501692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall 502b0d1dd36f104c0b581674adc7f830cbf44b7db06Andy McFadden // initialize EGL for the default display 50334a09ba1efd706323a15633da5044b352988eb5fJesse Hall mEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY); 50434a09ba1efd706323a15633da5044b352988eb5fJesse Hall eglInitialize(mEGLDisplay, NULL, NULL); 505a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian 506b0d1dd36f104c0b581674adc7f830cbf44b7db06Andy McFadden // Initialize the H/W composer object. There may or may not be an 507b0d1dd36f104c0b581674adc7f830cbf44b7db06Andy McFadden // actual hardware composer underneath. 508b0d1dd36f104c0b581674adc7f830cbf44b7db06Andy McFadden mHwc = new HWComposer(this, 509b0d1dd36f104c0b581674adc7f830cbf44b7db06Andy McFadden *static_cast<HWComposer::EventHandler *>(this)); 510b0d1dd36f104c0b581674adc7f830cbf44b7db06Andy McFadden 5112185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian // First try to get an ES2 config 512b65f32ebe2c86869b07ac1c986660dfb2187b7d3Jesse Hall err = selectEGLConfig(mEGLDisplay, mHwc->getVisualID(), EGL_OPENGL_ES2_BIT, 513b65f32ebe2c86869b07ac1c986660dfb2187b7d3Jesse Hall &mEGLConfig); 5142185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian 515b65f32ebe2c86869b07ac1c986660dfb2187b7d3Jesse Hall if (err != NO_ERROR) { 5162185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian // If ES2 fails, try ES1 517b65f32ebe2c86869b07ac1c986660dfb2187b7d3Jesse Hall err = selectEGLConfig(mEGLDisplay, mHwc->getVisualID(), 518b65f32ebe2c86869b07ac1c986660dfb2187b7d3Jesse Hall EGL_OPENGL_ES_BIT, &mEGLConfig); 5192185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian } 5202185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian 521b65f32ebe2c86869b07ac1c986660dfb2187b7d3Jesse Hall if (err != NO_ERROR) { 5222185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian // still didn't work, probably because we're on the emulator... 5232185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian // try a simplified query 5242185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian ALOGW("no suitable EGLConfig found, trying a simpler query"); 525b65f32ebe2c86869b07ac1c986660dfb2187b7d3Jesse Hall err = selectEGLConfig(mEGLDisplay, mHwc->getVisualID(), 0, &mEGLConfig); 5262185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian } 5272185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian 528b65f32ebe2c86869b07ac1c986660dfb2187b7d3Jesse Hall if (err != NO_ERROR) { 5292185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian // this EGL is too lame for android 5302185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian LOG_ALWAYS_FATAL("no suitable EGLConfig found, giving up"); 5312185f8b420ee1b150f761893a9c47cffff645cdeMathias Agopian } 532875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian 533875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian // print some debugging info 534875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian EGLint r,g,b,a; 535875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian eglGetConfigAttrib(mEGLDisplay, mEGLConfig, EGL_RED_SIZE, &r); 536875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian eglGetConfigAttrib(mEGLDisplay, mEGLConfig, EGL_GREEN_SIZE, &g); 537875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian eglGetConfigAttrib(mEGLDisplay, mEGLConfig, EGL_BLUE_SIZE, &b); 538875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian eglGetConfigAttrib(mEGLDisplay, mEGLConfig, EGL_ALPHA_SIZE, &a); 539875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian ALOGI("EGL informations:"); 540875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian ALOGI("vendor : %s", eglQueryString(mEGLDisplay, EGL_VENDOR)); 541875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian ALOGI("version : %s", eglQueryString(mEGLDisplay, EGL_VERSION)); 542875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian ALOGI("extensions: %s", eglQueryString(mEGLDisplay, EGL_EXTENSIONS)); 543875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian ALOGI("Client API: %s", eglQueryString(mEGLDisplay, EGL_CLIENT_APIS)?:"Not Supported"); 544875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian ALOGI("EGLSurface: %d-%d-%d-%d, config=%p", r, g, b, a, mEGLConfig); 545875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian 546875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian // get a RenderEngine for the given display / config (can't fail) 547875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian mRenderEngine = RenderEngine::create(mEGLDisplay, mEGLConfig); 548875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian 549875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian // retrieve the EGL context that was selected/created 550875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian mEGLContext = mRenderEngine->getEGLContext(); 551a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian 552ed985574148a938bc3af24442eead313cc62521cMathias Agopian // figure out which format we got 553ed985574148a938bc3af24442eead313cc62521cMathias Agopian eglGetConfigAttrib(mEGLDisplay, mEGLConfig, 554ed985574148a938bc3af24442eead313cc62521cMathias Agopian EGL_NATIVE_VISUAL_ID, &mEGLNativeVisualId); 555ed985574148a938bc3af24442eead313cc62521cMathias Agopian 556da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian LOG_ALWAYS_FATAL_IF(mEGLContext == EGL_NO_CONTEXT, 557da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian "couldn't create EGLContext"); 558da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian 559cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian // initialize our non-virtual displays 5609e663de4fe1dcc872373ee530c60a375624671c3Jesse Hall for (size_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) { 561f5a33928349bebc8eebc9f466618997e98c24e68Mathias Agopian DisplayDevice::DisplayType type((DisplayDevice::DisplayType)i); 562f5a33928349bebc8eebc9f466618997e98c24e68Mathias Agopian // set-up the displays that are already connected 5639e2463e71796964cfaa06bf09a880875ac3537bcMathias Agopian if (mHwc->isConnected(i) || type==DisplayDevice::DISPLAY_PRIMARY) { 564dd3cb84cfbe8068790c6233b5829fae9c4a0ee93Jamie Gennis // All non-virtual displays are currently considered secure. 565dd3cb84cfbe8068790c6233b5829fae9c4a0ee93Jamie Gennis bool isSecure = true; 566692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall createBuiltinDisplayLocked(type); 567692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall wp<IBinder> token = mBuiltinDisplays[i]; 568692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall 569db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian sp<BufferQueue> bq = new BufferQueue(new GraphicBufferAlloc()); 570db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian sp<FramebufferSurface> fbs = new FramebufferSurface(*mHwc, i, bq); 571f5a33928349bebc8eebc9f466618997e98c24e68Mathias Agopian sp<DisplayDevice> hw = new DisplayDevice(this, 572ffe1f19ca9707f84cb9fdb06209bf36cd8c2ef0aJesse Hall type, allocateHwcDisplayId(type), isSecure, token, 573db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian fbs, bq, 57499c7dbb24994df2f3e175f7b25dd2c9dd92a72f0Jesse Hall mEGLConfig); 575f5a33928349bebc8eebc9f466618997e98c24e68Mathias Agopian if (i > DisplayDevice::DISPLAY_PRIMARY) { 576c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden // FIXME: currently we don't get blank/unblank requests 577f5a33928349bebc8eebc9f466618997e98c24e68Mathias Agopian // for displays other than the main display, so we always 578f5a33928349bebc8eebc9f466618997e98c24e68Mathias Agopian // assume a connected display is unblanked. 579c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden ALOGD("marking display %d as acquired/unblanked", i); 580f5a33928349bebc8eebc9f466618997e98c24e68Mathias Agopian hw->acquireScreen(); 581f5a33928349bebc8eebc9f466618997e98c24e68Mathias Agopian } 582f5a33928349bebc8eebc9f466618997e98c24e68Mathias Agopian mDisplays.add(token, hw); 583f5a33928349bebc8eebc9f466618997e98c24e68Mathias Agopian } 584e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 585cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian 586a6bb107434ad36739c21e1f72ac8d0107808a7b9Mathias Agopian // make the GLContext current so that we can create textures when creating Layers 587a6bb107434ad36739c21e1f72ac8d0107808a7b9Mathias Agopian // (which may happens before we render something) 588a6bb107434ad36739c21e1f72ac8d0107808a7b9Mathias Agopian getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext); 589a6bb107434ad36739c21e1f72ac8d0107808a7b9Mathias Agopian 590028508cad5ef63ef9fbd42c14e76658e4fd9ebf2Mathias Agopian // start the EventThread 591faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync); 592faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mEventThread = new EventThread(vsyncSrc); 593028508cad5ef63ef9fbd42c14e76658e4fd9ebf2Mathias Agopian mEventQueue.setEventThread(mEventThread); 594028508cad5ef63ef9fbd42c14e76658e4fd9ebf2Mathias Agopian 595faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis // set a fake vsync period if there is no HWComposer 596faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (mHwc->initCheck() != NO_ERROR) { 597faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mPrimaryDispSync.setPeriod(16666667); 598faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 599faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 60092a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // initialize our drawing state 60192a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian mDrawingState = mCurrentState; 6028630320433bd15aca239522e54e711ef6372ab07Mathias Agopian 60313a082e160c2d1d8006b93a555a57035213d568bAndy McFadden // set initial conditions (e.g. unblank default device) 60413a082e160c2d1d8006b93a555a57035213d568bAndy McFadden initializeDisplays(); 60513a082e160c2d1d8006b93a555a57035213d568bAndy McFadden 606a1ecca920e15ce04fe56ebf4f1b52ba711f9eb2dMathias Agopian // start boot animation 607a67e418e1fda219f6cc0a7e420bcf5cc4f9fe710Mathias Agopian startBootAnim(); 608edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 609edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 6103ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias Agopianint32_t SurfaceFlinger::allocateHwcDisplayId(DisplayDevice::DisplayType type) { 6119e663de4fe1dcc872373ee530c60a375624671c3Jesse Hall return (uint32_t(type) < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) ? 6123ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias Agopian type : mHwc->allocateDisplayId(); 6133ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias Agopian} 6143ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias Agopian 615a67e418e1fda219f6cc0a7e420bcf5cc4f9fe710Mathias Agopianvoid SurfaceFlinger::startBootAnim() { 616a67e418e1fda219f6cc0a7e420bcf5cc4f9fe710Mathias Agopian // start boot animation 617a67e418e1fda219f6cc0a7e420bcf5cc4f9fe710Mathias Agopian property_set("service.bootanim.exit", "0"); 618a67e418e1fda219f6cc0a7e420bcf5cc4f9fe710Mathias Agopian property_set("ctl.start", "bootanim"); 619a67e418e1fda219f6cc0a7e420bcf5cc4f9fe710Mathias Agopian} 620a67e418e1fda219f6cc0a7e420bcf5cc4f9fe710Mathias Agopian 621875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopiansize_t SurfaceFlinger::getMaxTextureSize() const { 622875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian return mRenderEngine->getMaxTextureSize(); 623a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian} 624a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian 625875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopiansize_t SurfaceFlinger::getMaxViewportDims() const { 626875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian return mRenderEngine->getMaxViewportDims(); 627a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian} 628a49126087b4494f4ef50873f3a3f6727265f6621Mathias Agopian 629edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project// ---------------------------------------------------------------------------- 630d0566bc26fcf6ca396118701fa11900b627f2c09Mathias Agopian 631582270d69db94286a248bd829f1ae6f910d45124Jamie Gennisbool SurfaceFlinger::authenticateSurfaceTexture( 6322adaf04fab35cf47c824d74d901b54094e01ccd3Andy McFadden const sp<IGraphicBufferProducer>& bufferProducer) const { 633134f0422866e8985188ed10dfbdcb8e6c34b87f7Jamie Gennis Mutex::Autolock _l(mStateLock); 6342adaf04fab35cf47c824d74d901b54094e01ccd3Andy McFadden sp<IBinder> surfaceTextureBinder(bufferProducer->asBinder()); 6356710604286401d4205c27235a252dd0e5008cc08Mathias Agopian return mGraphicBufferProducerList.indexOf(surfaceTextureBinder) >= 0; 636134f0422866e8985188ed10dfbdcb8e6c34b87f7Jamie Gennis} 637134f0422866e8985188ed10dfbdcb8e6c34b87f7Jamie Gennis 6389d4e3d2f42e93e2d12bacabe97d307d30c3c20ddJeff Brownstatus_t SurfaceFlinger::getDisplayInfo(const sp<IBinder>& display, DisplayInfo* info) { 639692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall int32_t type = NAME_NOT_FOUND; 6409e663de4fe1dcc872373ee530c60a375624671c3Jesse Hall for (int i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) { 641692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall if (display == mBuiltinDisplays[i]) { 6421604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian type = i; 6431604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian break; 6441604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian } 6451604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian } 6461604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian 6471604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian if (type < 0) { 6481604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian return type; 649c666cae2d5995097ec49a87e375e2afdd92802b7Mathias Agopian } 6508b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian 6518b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian const HWComposer& hwc(getHwComposer()); 6521604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian float xdpi = hwc.getDpiX(type); 6531604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian float ydpi = hwc.getDpiY(type); 6548b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian 6558b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian // TODO: Not sure if display density should handled by SF any longer 6568b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian class Density { 6578b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian static int getDensityFromProperty(char const* propName) { 6588b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian char property[PROPERTY_VALUE_MAX]; 6598b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian int density = 0; 6608b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian if (property_get(propName, property, NULL) > 0) { 6618b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian density = atoi(property); 6628b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian } 6638b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian return density; 6648b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian } 6658b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian public: 6668b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian static int getEmuDensity() { 6678b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian return getDensityFromProperty("qemu.sf.lcd_density"); } 6688b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian static int getBuildDensity() { 6698b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian return getDensityFromProperty("ro.sf.lcd_density"); } 6708b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian }; 6711604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian 6721604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian if (type == DisplayDevice::DISPLAY_PRIMARY) { 6731604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian // The density of the device is provided by a build property 6741604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian float density = Density::getBuildDensity() / 160.0f; 6751604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian if (density == 0) { 6761604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian // the build doesn't provide a density -- this is wrong! 6771604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian // use xdpi instead 6781604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian ALOGE("ro.sf.lcd_density must be defined as a build property"); 6791604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian density = xdpi / 160.0f; 6801604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian } 6811604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian if (Density::getEmuDensity()) { 6821604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian // if "qemu.sf.lcd_density" is specified, it overrides everything 6831604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian xdpi = ydpi = density = Density::getEmuDensity(); 6841604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian density /= 160.0f; 6851604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian } 6861604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian info->density = density; 6871604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian 6881604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian // TODO: this needs to go away (currently needed only by webkit) 6891604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian sp<const DisplayDevice> hw(getDefaultDisplayDevice()); 6901604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian info->orientation = hw->getOrientation(); 6911604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian } else { 6921604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian // TODO: where should this value come from? 6931604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian static const int TV_DENSITY = 213; 6941604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian info->density = TV_DENSITY / 160.0f; 6951604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian info->orientation = 0; 6968b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian } 6978b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian 6981604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian info->w = hwc.getWidth(type); 6991604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian info->h = hwc.getHeight(type); 7008b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian info->xdpi = xdpi; 7018b736f138cfd9b239a2c7073347a13c489534ae1Mathias Agopian info->ydpi = ydpi; 7021604f777d11c40daae8ec91d8ea75625996bfbacMathias Agopian info->fps = float(1e9 / hwc.getRefreshPeriod(type)); 703dd3cb84cfbe8068790c6233b5829fae9c4a0ee93Jamie Gennis 704dd3cb84cfbe8068790c6233b5829fae9c4a0ee93Jamie Gennis // All non-virtual displays are currently considered secure. 705dd3cb84cfbe8068790c6233b5829fae9c4a0ee93Jamie Gennis info->secure = true; 706dd3cb84cfbe8068790c6233b5829fae9c4a0ee93Jamie Gennis 707888c822c4cb6976aab9256c58bae9e17e3e55c5cMathias Agopian return NO_ERROR; 708c666cae2d5995097ec49a87e375e2afdd92802b7Mathias Agopian} 709c666cae2d5995097ec49a87e375e2afdd92802b7Mathias Agopian 710d0566bc26fcf6ca396118701fa11900b627f2c09Mathias Agopian// ---------------------------------------------------------------------------- 711d0566bc26fcf6ca396118701fa11900b627f2c09Mathias Agopian 712d0566bc26fcf6ca396118701fa11900b627f2c09Mathias Agopiansp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection() { 7138aedd4737d6ce8548d2fd5def65b1e1737283821Mathias Agopian return mEventThread->createEventConnection(); 714bb641244d7d73312dc65b8e338df18b22e335107Mathias Agopian} 715bb641244d7d73312dc65b8e338df18b22e335107Mathias Agopian 716edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project// ---------------------------------------------------------------------------- 71799ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian 71899ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopianvoid SurfaceFlinger::waitForEvent() { 71999ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian mEventQueue.waitMessage(); 72099ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian} 72199ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian 72299ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopianvoid SurfaceFlinger::signalTransaction() { 72399ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian mEventQueue.invalidate(); 72499ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian} 72599ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian 72699ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopianvoid SurfaceFlinger::signalLayerUpdate() { 72799ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian mEventQueue.invalidate(); 72899ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian} 72999ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian 73099ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopianvoid SurfaceFlinger::signalRefresh() { 73199ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian mEventQueue.refresh(); 73299ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian} 73399ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian 73499ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopianstatus_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg, 73599ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian nsecs_t reltime, uint32_t flags) { 73699ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian return mEventQueue.postMessage(msg, reltime); 73799ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian} 73899ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian 73999ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopianstatus_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg, 74099ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian nsecs_t reltime, uint32_t flags) { 74199ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian status_t res = mEventQueue.postMessage(msg, reltime); 74299ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian if (res == NO_ERROR) { 74399ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian msg->wait(); 74499ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian } 74599ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian return res; 74699ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian} 747edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 7484f4f0943489d9113c66ac22b58cfba8c21dfa879Mathias Agopianvoid SurfaceFlinger::run() { 7494f4f0943489d9113c66ac22b58cfba8c21dfa879Mathias Agopian do { 7504f4f0943489d9113c66ac22b58cfba8c21dfa879Mathias Agopian waitForEvent(); 7514f4f0943489d9113c66ac22b58cfba8c21dfa879Mathias Agopian } while (true); 75299ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian} 753edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 754faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennisvoid SurfaceFlinger::enableHardwareVsync() { 755faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis Mutex::Autolock _l(mHWVsyncLock); 756948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall if (!mPrimaryHWVsyncEnabled && mHWVsyncAvailable) { 757faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mPrimaryDispSync.beginResync(); 758faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, true); 759faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mPrimaryHWVsyncEnabled = true; 76043601a2dc320a271ff8c3765ff61414a07221635Andy McFadden } 761faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis} 762faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 763948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hallvoid SurfaceFlinger::resyncToHardwareVsync(bool makeAvailable) { 764faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis Mutex::Autolock _l(mHWVsyncLock); 765faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 766948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall if (makeAvailable) { 767948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall mHWVsyncAvailable = true; 768948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall } else if (!mHWVsyncAvailable) { 769948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall ALOGE("resyncToHardwareVsync called when HW vsync unavailable"); 770948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall return; 771948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall } 772948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall 773faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis const nsecs_t period = 774faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY); 775faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 776faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mPrimaryDispSync.reset(); 777faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mPrimaryDispSync.setPeriod(period); 778faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 779faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (!mPrimaryHWVsyncEnabled) { 780faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mPrimaryDispSync.beginResync(); 781faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, true); 782faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mPrimaryHWVsyncEnabled = true; 783faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 784faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis} 785faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 786948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hallvoid SurfaceFlinger::disableHardwareVsync(bool makeUnavailable) { 787faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis Mutex::Autolock _l(mHWVsyncLock); 788faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (mPrimaryHWVsyncEnabled) { 789faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, false); 790faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mPrimaryDispSync.endResync(); 791faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis mPrimaryHWVsyncEnabled = false; 792faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 793948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall if (makeUnavailable) { 794948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall mHWVsyncAvailable = false; 795948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall } 796faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis} 797faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 798faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennisvoid SurfaceFlinger::onVSyncReceived(int type, nsecs_t timestamp) { 799faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (type == 0) { 800faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis bool needsHwVsync = mPrimaryDispSync.addResyncSample(timestamp); 801faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 802faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (needsHwVsync) { 803faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis enableHardwareVsync(); 804faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } else { 805948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall disableHardwareVsync(false); 806faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 807148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopian } 808148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopian} 809148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopian 810148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopianvoid SurfaceFlinger::onHotplugReceived(int type, bool connected) { 811148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopian if (mEventThread == NULL) { 812148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopian // This is a temporary workaround for b/7145521. A non-null pointer 813148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopian // does not mean EventThread has finished initializing, so this 814148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopian // is not a correct fix. 815148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopian ALOGW("WARNING: EventThread not started, ignoring hotplug"); 816148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopian return; 817148994e5f33ce240ff24ceb5bc0500b7f2001959Mathias Agopian } 8189e2463e71796964cfaa06bf09a880875ac3537bcMathias Agopian 8199e663de4fe1dcc872373ee530c60a375624671c3Jesse Hall if (uint32_t(type) < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) { 8209e2463e71796964cfaa06bf09a880875ac3537bcMathias Agopian Mutex::Autolock _l(mStateLock); 821692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall if (connected) { 822692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall createBuiltinDisplayLocked((DisplayDevice::DisplayType)type); 8239e2463e71796964cfaa06bf09a880875ac3537bcMathias Agopian } else { 824692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall mCurrentState.displays.removeItem(mBuiltinDisplays[type]); 825692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall mBuiltinDisplays[type].clear(); 8269e2463e71796964cfaa06bf09a880875ac3537bcMathias Agopian } 8279e2463e71796964cfaa06bf09a880875ac3537bcMathias Agopian setTransactionFlags(eDisplayTransactionNeeded); 8289e2463e71796964cfaa06bf09a880875ac3537bcMathias Agopian 8299e9689c11148521d2c16a121a0b87b062be0714cAndy McFadden // Defer EventThread notification until SF has updated mDisplays. 8303ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias Agopian } 8318630320433bd15aca239522e54e711ef6372ab07Mathias Agopian} 8328630320433bd15aca239522e54e711ef6372ab07Mathias Agopian 83381cd5d3b94d21253a0be925f4ae58cc7f4afeef7Mathias Agopianvoid SurfaceFlinger::eventControl(int disp, int event, int enabled) { 834faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis ATRACE_CALL(); 83581cd5d3b94d21253a0be925f4ae58cc7f4afeef7Mathias Agopian getHwComposer().eventControl(disp, event, enabled); 8368630320433bd15aca239522e54e711ef6372ab07Mathias Agopian} 8378630320433bd15aca239522e54e711ef6372ab07Mathias Agopian 8384fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopianvoid SurfaceFlinger::onMessageReceived(int32_t what) { 8391c8e95cf86f2182986385bc1ee85f13f425f3a3aJamie Gennis ATRACE_CALL(); 84099ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian switch (what) { 8419eb1f0558b5fc78920602afe7bcfa3115bb1f6beMathias Agopian case MessageQueue::TRANSACTION: 8429eb1f0558b5fc78920602afe7bcfa3115bb1f6beMathias Agopian handleMessageTransaction(); 8439eb1f0558b5fc78920602afe7bcfa3115bb1f6beMathias Agopian break; 8444fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian case MessageQueue::INVALIDATE: 8454fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian handleMessageTransaction(); 8464fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian handleMessageInvalidate(); 8474fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian signalRefresh(); 8484fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian break; 8494fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian case MessageQueue::REFRESH: 8504fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian handleMessageRefresh(); 8514fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian break; 8524fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian } 8534fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian} 854edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 8554fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopianvoid SurfaceFlinger::handleMessageTransaction() { 856e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian uint32_t transactionFlags = peekTransactionFlags(eTransactionMask); 8574fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian if (transactionFlags) { 85887baae104a3e4c2059990b01c393476065c558b0Mathias Agopian handleTransaction(transactionFlags); 8594fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian } 8604fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian} 861edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 8624fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopianvoid SurfaceFlinger::handleMessageInvalidate() { 863cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian ATRACE_CALL(); 86487baae104a3e4c2059990b01c393476065c558b0Mathias Agopian handlePageFlip(); 8654fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian} 8663a3cad30c40c8eb87671262a9fe7f0e214b6a934Mathias Agopian 8674fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopianvoid SurfaceFlinger::handleMessageRefresh() { 868cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian ATRACE_CALL(); 869cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian preComposition(); 870cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian rebuildLayerStacks(); 871cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian setUpHWComposer(); 872cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian doDebugFlashRegions(); 873cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian doComposition(); 874cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian postComposition(); 875cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian} 876cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian 877cd60f99aba9e750700a967db30b74a29145739cfMathias Agopianvoid SurfaceFlinger::doDebugFlashRegions() 878cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian{ 879cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian // is debugging enabled 880cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian if (CC_LIKELY(!mDebugRegion)) 881cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian return; 882cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian 883cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian const bool repaintEverything = mRepaintEverything; 884cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 885cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian const sp<DisplayDevice>& hw(mDisplays[dpy]); 886cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian if (hw->canDraw()) { 887cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian // transform the dirty region into this screen's coordinate space 888cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian const Region dirtyRegion(hw->getDirtyRegion(repaintEverything)); 889cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian if (!dirtyRegion.isEmpty()) { 890cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian // redraw the whole screen 891cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian doComposeSurfaces(hw, Region(hw->bounds())); 892cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian 893cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian // and draw the dirty region 894cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian const int32_t height = hw->getHeight(); 8953f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian RenderEngine& engine(getRenderEngine()); 8963f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian engine.fillRegionWithColor(dirtyRegion, height, 1, 0, 1, 1); 8973f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian 898cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian hw->compositionComplete(); 899da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian hw->swapBuffers(getHwComposer()); 900cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } 901cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } 902cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } 903cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian 904cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian postFramebuffer(); 905cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian 906cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian if (mDebugRegion > 1) { 907cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian usleep(mDebugRegion * 1000); 908cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } 909bb53b0e4b97634bc31808965f81b3ab4193d0e84Mathias Agopian 910bb53b0e4b97634bc31808965f81b3ab4193d0e84Mathias Agopian HWComposer& hwc(getHwComposer()); 911bb53b0e4b97634bc31808965f81b3ab4193d0e84Mathias Agopian if (hwc.initCheck() == NO_ERROR) { 912bb53b0e4b97634bc31808965f81b3ab4193d0e84Mathias Agopian status_t err = hwc.prepare(); 913bb53b0e4b97634bc31808965f81b3ab4193d0e84Mathias Agopian ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err)); 914bb53b0e4b97634bc31808965f81b3ab4193d0e84Mathias Agopian } 915cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian} 916cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian 917cd60f99aba9e750700a967db30b74a29145739cfMathias Agopianvoid SurfaceFlinger::preComposition() 918cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian{ 919cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian bool needExtraInvalidate = false; 9201eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const LayerVector& layers(mDrawingState.layersSortedByZ); 9211eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const size_t count = layers.size(); 922cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian for (size_t i=0 ; i<count ; i++) { 9231eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian if (layers[i]->onPreComposition()) { 924cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian needExtraInvalidate = true; 925cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } 926cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } 927cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian if (needExtraInvalidate) { 928cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian signalLayerUpdate(); 929cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } 930cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian} 931a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian 932cd60f99aba9e750700a967db30b74a29145739cfMathias Agopianvoid SurfaceFlinger::postComposition() 933cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian{ 9341eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const LayerVector& layers(mDrawingState.layersSortedByZ); 9351eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const size_t count = layers.size(); 936cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian for (size_t i=0 ; i<count ; i++) { 9371eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian layers[i]->onPostComposition(); 938cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } 9394b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis 940faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis const HWComposer& hwc = getHwComposer(); 941faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY); 942faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 943faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (presentFence->isValid()) { 944faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (mPrimaryDispSync.addPresentFence(presentFence)) { 945faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis enableHardwareVsync(); 946faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } else { 947948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall disableHardwareVsync(false); 948faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 949faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 950faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 951faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (runningWithoutSyncFramework) { 952faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis const sp<const DisplayDevice> hw(getDefaultDisplayDevice()); 953faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis if (hw->isScreenAcquired()) { 954faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis enableHardwareVsync(); 955faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 956faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis } 957faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 9584b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis if (mAnimCompositionPending) { 9594b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis mAnimCompositionPending = false; 9604b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis 961a9a1b006e48320f5c501473e51e6c4a5f7a17b88Jesse Hall if (presentFence->isValid()) { 9624b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis mAnimFrameTracker.setActualPresentFence(presentFence); 9634b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis } else { 9644b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis // The HWC doesn't support present fences, so use the refresh 9654b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis // timestamp instead. 9664b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY); 9674b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis mAnimFrameTracker.setActualPresentTime(presentTime); 9684b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis } 9694b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis mAnimFrameTracker.advanceFrame(); 9704b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis } 971cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian} 972cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian 973cd60f99aba9e750700a967db30b74a29145739cfMathias Agopianvoid SurfaceFlinger::rebuildLayerStacks() { 974cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian // rebuild the visible layer list per screen 97552bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian if (CC_UNLIKELY(mVisibleRegionsDirty)) { 976cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian ATRACE_CALL(); 97787baae104a3e4c2059990b01c393476065c558b0Mathias Agopian mVisibleRegionsDirty = false; 97887baae104a3e4c2059990b01c393476065c558b0Mathias Agopian invalidateHwcGeometry(); 979ce3a0a541c3dde1330551bd7a048cd9d92335c00Mathias Agopian 9801eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const LayerVector& layers(mDrawingState.layersSortedByZ); 98192a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 982ce3a0a541c3dde1330551bd7a048cd9d92335c00Mathias Agopian Region opaqueRegion; 983ce3a0a541c3dde1330551bd7a048cd9d92335c00Mathias Agopian Region dirtyRegion; 98413127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian Vector< sp<Layer> > layersSortedByZ; 9854297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian const sp<DisplayDevice>& hw(mDisplays[dpy]); 9867e7ed7f77a3963a3542bde529d2797a239e2798bMathias Agopian const Transform& tr(hw->getTransform()); 9877e7ed7f77a3963a3542bde529d2797a239e2798bMathias Agopian const Rect bounds(hw->getBounds()); 988ce3a0a541c3dde1330551bd7a048cd9d92335c00Mathias Agopian if (hw->canDraw()) { 9891eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian SurfaceFlinger::computeVisibleRegions(layers, 990ce3a0a541c3dde1330551bd7a048cd9d92335c00Mathias Agopian hw->getLayerStack(), dirtyRegion, opaqueRegion); 9917e7ed7f77a3963a3542bde529d2797a239e2798bMathias Agopian 9921eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const size_t count = layers.size(); 993ce3a0a541c3dde1330551bd7a048cd9d92335c00Mathias Agopian for (size_t i=0 ; i<count ; i++) { 9941eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const sp<Layer>& layer(layers[i]); 9951eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const Layer::State& s(layer->getDrawingState()); 996ce3a0a541c3dde1330551bd7a048cd9d92335c00Mathias Agopian if (s.layerStack == hw->getLayerStack()) { 997a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall Region drawRegion(tr.transform( 998a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall layer->visibleNonTransparentRegion)); 999a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall drawRegion.andSelf(bounds); 1000a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall if (!drawRegion.isEmpty()) { 1001ce3a0a541c3dde1330551bd7a048cd9d92335c00Mathias Agopian layersSortedByZ.add(layer); 1002ce3a0a541c3dde1330551bd7a048cd9d92335c00Mathias Agopian } 100387baae104a3e4c2059990b01c393476065c558b0Mathias Agopian } 100487baae104a3e4c2059990b01c393476065c558b0Mathias Agopian } 10053b1d2b6b2bbfb5df46b1059ec52360974e6f1428Mathias Agopian } 10064297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian hw->setVisibleLayersSortedByZ(layersSortedByZ); 10077e7ed7f77a3963a3542bde529d2797a239e2798bMathias Agopian hw->undefinedRegion.set(bounds); 10087e7ed7f77a3963a3542bde529d2797a239e2798bMathias Agopian hw->undefinedRegion.subtractSelf(tr.transform(opaqueRegion)); 10097e7ed7f77a3963a3542bde529d2797a239e2798bMathias Agopian hw->dirtyRegion.orSelf(dirtyRegion); 10103b1d2b6b2bbfb5df46b1059ec52360974e6f1428Mathias Agopian } 10113b1d2b6b2bbfb5df46b1059ec52360974e6f1428Mathias Agopian } 1012cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian} 10133b1d2b6b2bbfb5df46b1059ec52360974e6f1428Mathias Agopian 1014cd60f99aba9e750700a967db30b74a29145739cfMathias Agopianvoid SurfaceFlinger::setUpHWComposer() { 1015028dc8f2d72bc7cd4fbe7808781443125a742f78Jesse Hall for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 1016028dc8f2d72bc7cd4fbe7808781443125a742f78Jesse Hall mDisplays[dpy]->beginFrame(); 1017028dc8f2d72bc7cd4fbe7808781443125a742f78Jesse Hall } 1018028dc8f2d72bc7cd4fbe7808781443125a742f78Jesse Hall 101952bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian HWComposer& hwc(getHwComposer()); 102052bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian if (hwc.initCheck() == NO_ERROR) { 102152bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian // build the h/w work list 1022a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis if (CC_UNLIKELY(mHwWorkListDirty)) { 1023a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis mHwWorkListDirty = false; 1024a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 1025a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis sp<const DisplayDevice> hw(mDisplays[dpy]); 1026a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis const int32_t id = hw->getHwcDisplayId(); 1027a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis if (id >= 0) { 102813127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const Vector< sp<Layer> >& currentLayers( 1029a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis hw->getVisibleLayersSortedByZ()); 1030a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis const size_t count = currentLayers.size(); 1031a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis if (hwc.createWorkList(id, count) == NO_ERROR) { 1032a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis HWComposer::LayerListIterator cur = hwc.begin(id); 1033a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis const HWComposer::LayerListIterator end = hwc.end(id); 1034a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) { 103513127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer(currentLayers[i]); 1036a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis layer->setGeometry(hw, *cur); 1037ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian if (mDebugDisableHWC || mDebugRegion || mDaltonize) { 1038a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis cur->setSkip(true); 1039a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis } 1040a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis } 1041a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis } 1042a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis } 1043a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis } 1044a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis } 1045a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis 1046a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis // set the per-frame data 104792a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 10484297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian sp<const DisplayDevice> hw(mDisplays[dpy]); 1049e60b0687c8d49871d0c8786cabe6851f7a7783b5Mathias Agopian const int32_t id = hw->getHwcDisplayId(); 1050e60b0687c8d49871d0c8786cabe6851f7a7783b5Mathias Agopian if (id >= 0) { 105113127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const Vector< sp<Layer> >& currentLayers( 1052cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian hw->getVisibleLayersSortedByZ()); 1053e60b0687c8d49871d0c8786cabe6851f7a7783b5Mathias Agopian const size_t count = currentLayers.size(); 1054a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis HWComposer::LayerListIterator cur = hwc.begin(id); 1055a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis const HWComposer::LayerListIterator end = hwc.end(id); 1056a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) { 1057a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis /* 1058a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis * update the per-frame h/w composer data for each layer 1059a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis * and build the transparent region of the FB 1060a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis */ 106113127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer(currentLayers[i]); 1062a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis layer->setPerFrameData(hw, *cur); 10631e26087493ac0e7d7dc6dea8ad85cfef08b3271fMathias Agopian } 106452bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian } 106587baae104a3e4c2059990b01c393476065c558b0Mathias Agopian } 1066a4310c8be2dc3406a668ee99020d52187173232fJamie Gennis 106752bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian status_t err = hwc.prepare(); 106852bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err)); 106938efe86d9459cf5c96a24a34cc5cbf31fdba7e19Jesse Hall 107038efe86d9459cf5c96a24a34cc5cbf31fdba7e19Jesse Hall for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 107138efe86d9459cf5c96a24a34cc5cbf31fdba7e19Jesse Hall sp<const DisplayDevice> hw(mDisplays[dpy]); 107238efe86d9459cf5c96a24a34cc5cbf31fdba7e19Jesse Hall hw->prepareFrame(hwc); 107338efe86d9459cf5c96a24a34cc5cbf31fdba7e19Jesse Hall } 107452bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian } 1075cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian} 107652bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian 1077cd60f99aba9e750700a967db30b74a29145739cfMathias Agopianvoid SurfaceFlinger::doComposition() { 1078cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian ATRACE_CALL(); 107952bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian const bool repaintEverything = android_atomic_and(0, &mRepaintEverything); 108092a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 10814297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian const sp<DisplayDevice>& hw(mDisplays[dpy]); 1082cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian if (hw->canDraw()) { 1083cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian // transform the dirty region into this screen's coordinate space 1084cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian const Region dirtyRegion(hw->getDirtyRegion(repaintEverything)); 108502b95105754b1859a97e234b79f41489a4677c20Mathias Agopian 108602b95105754b1859a97e234b79f41489a4677c20Mathias Agopian // repaint the framebuffer (if needed) 108702b95105754b1859a97e234b79f41489a4677c20Mathias Agopian doDisplayComposition(hw, dirtyRegion); 108802b95105754b1859a97e234b79f41489a4677c20Mathias Agopian 1089cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian hw->dirtyRegion.clear(); 1090cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian hw->flip(hw->swapRegion); 1091cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian hw->swapRegion.clear(); 109287baae104a3e4c2059990b01c393476065c558b0Mathias Agopian } 109352bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian // inform the h/w that we're done compositing 10944297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian hw->compositionComplete(); 10954fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian } 109652bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian postFramebuffer(); 1097edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1098edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1099edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Projectvoid SurfaceFlinger::postFramebuffer() 1100edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 1101841cde55549cea7a344a1705b18d57a0c6c8ec45Mathias Agopian ATRACE_CALL(); 1102b048cef231075a5e41d224b73fe11fec62f335b1Mathias Agopian 1103a44b04163957d6086362f6f365443c4c93379031Mathias Agopian const nsecs_t now = systemTime(); 1104a44b04163957d6086362f6f365443c4c93379031Mathias Agopian mDebugInSwapBuffers = now; 1105c5c5a14c06de249d8e0445fd24699e1d9aa04549Jesse Hall 110652bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian HWComposer& hwc(getHwComposer()); 1107ef19414bd8b77a26f5751f3845be79025a8263feJesse Hall if (hwc.initCheck() == NO_ERROR) { 11082a23184e4109060ec772763e80dae2132cf9d2ebMathias Agopian if (!hwc.supportsFramebufferTarget()) { 11092a23184e4109060ec772763e80dae2132cf9d2ebMathias Agopian // EGL spec says: 11102a23184e4109060ec772763e80dae2132cf9d2ebMathias Agopian // "surface must be bound to the calling thread's current context, 11112a23184e4109060ec772763e80dae2132cf9d2ebMathias Agopian // for the current rendering API." 1112875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext); 11132a23184e4109060ec772763e80dae2132cf9d2ebMathias Agopian } 1114e60b0687c8d49871d0c8786cabe6851f7a7783b5Mathias Agopian hwc.commit(); 111552bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian } 111652bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian 11176da15f46f5f8b38e31384d641f8d3db2c3c6ea30Mathias Agopian // make the default display current because the VirtualDisplayDevice code cannot 11186da15f46f5f8b38e31384d641f8d3db2c3c6ea30Mathias Agopian // deal with dequeueBuffer() being called outside of the composition loop; however 11196da15f46f5f8b38e31384d641f8d3db2c3c6ea30Mathias Agopian // the code below can call glFlush() which is allowed (and does in some case) call 11206da15f46f5f8b38e31384d641f8d3db2c3c6ea30Mathias Agopian // dequeueBuffer(). 11216da15f46f5f8b38e31384d641f8d3db2c3c6ea30Mathias Agopian getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext); 11226da15f46f5f8b38e31384d641f8d3db2c3c6ea30Mathias Agopian 112392a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 11244297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian sp<const DisplayDevice> hw(mDisplays[dpy]); 112513127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const Vector< sp<Layer> >& currentLayers(hw->getVisibleLayersSortedByZ()); 1126da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian hw->onSwapBuffersCompleted(hwc); 112752bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian const size_t count = currentLayers.size(); 1128e60b0687c8d49871d0c8786cabe6851f7a7783b5Mathias Agopian int32_t id = hw->getHwcDisplayId(); 1129e60b0687c8d49871d0c8786cabe6851f7a7783b5Mathias Agopian if (id >=0 && hwc.initCheck() == NO_ERROR) { 11301e26087493ac0e7d7dc6dea8ad85cfef08b3271fMathias Agopian HWComposer::LayerListIterator cur = hwc.begin(id); 11311e26087493ac0e7d7dc6dea8ad85cfef08b3271fMathias Agopian const HWComposer::LayerListIterator end = hwc.end(id); 113252bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian for (size_t i = 0; cur != end && i < count; ++i, ++cur) { 1133d3ee231eddce0b69ec5e35188dbd0f4a2c3b9ac3Mathias Agopian currentLayers[i]->onLayerDisplayed(hw, &*cur); 113452bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian } 1135cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } else { 113652bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian for (size_t i = 0; i < count; i++) { 1137d3ee231eddce0b69ec5e35188dbd0f4a2c3b9ac3Mathias Agopian currentLayers[i]->onLayerDisplayed(hw, NULL); 113852bbb1ae239c8a4d05543a23fa8c08467d09c3b2Mathias Agopian } 1139ef19414bd8b77a26f5751f3845be79025a8263feJesse Hall } 1140e8696a40e09b24b634214684d18526187b316a2fJamie Gennis } 1141e8696a40e09b24b634214684d18526187b316a2fJamie Gennis 1142a44b04163957d6086362f6f365443c4c93379031Mathias Agopian mLastSwapBufferTime = systemTime() - now; 1143a44b04163957d6086362f6f365443c4c93379031Mathias Agopian mDebugInSwapBuffers = 0; 11446547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis 11456547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis uint32_t flipCount = getDefaultDisplayDevice()->getPageFlipCount(); 11466547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis if (flipCount % LOG_FRAME_STATS_PERIOD == 0) { 11476547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis logFrameStats(); 11486547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis } 1149edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1150edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 115187baae104a3e4c2059990b01c393476065c558b0Mathias Agopianvoid SurfaceFlinger::handleTransaction(uint32_t transactionFlags) 1152edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 1153841cde55549cea7a344a1705b18d57a0c6c8ec45Mathias Agopian ATRACE_CALL(); 1154841cde55549cea7a344a1705b18d57a0c6c8ec45Mathias Agopian 11557cc6df59572582652078df5aeac9e6c67d7fa81eMathias Agopian // here we keep a copy of the drawing state (that is the state that's 11567cc6df59572582652078df5aeac9e6c67d7fa81eMathias Agopian // going to be overwritten by handleTransactionLocked()) outside of 11577cc6df59572582652078df5aeac9e6c67d7fa81eMathias Agopian // mStateLock so that the side-effects of the State assignment 11587cc6df59572582652078df5aeac9e6c67d7fa81eMathias Agopian // don't happen with mStateLock held (which can cause deadlocks). 11597cc6df59572582652078df5aeac9e6c67d7fa81eMathias Agopian State drawingState(mDrawingState); 11607cc6df59572582652078df5aeac9e6c67d7fa81eMathias Agopian 1161ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian Mutex::Autolock _l(mStateLock); 1162ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian const nsecs_t now = systemTime(); 1163ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian mDebugInTransaction = now; 1164ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian 1165ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian // Here we're guaranteed that some transaction flags are set 1166ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian // so we can call handleTransactionLocked() unconditionally. 1167ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian // We call getTransactionFlags(), which will also clear the flags, 1168ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian // with mStateLock held to guarantee that mCurrentState won't change 1169ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian // until the transaction is committed. 1170ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian 1171e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian transactionFlags = getTransactionFlags(eTransactionMask); 117287baae104a3e4c2059990b01c393476065c558b0Mathias Agopian handleTransactionLocked(transactionFlags); 1173ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian 1174ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian mLastTransactionTime = systemTime() - now; 1175ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian mDebugInTransaction = 0; 1176ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian invalidateHwcGeometry(); 1177ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian // here the transaction has been committed 11783d57964a81cd631d80aa9575647e1ce35b5e82d5Mathias Agopian} 1179edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 118087baae104a3e4c2059990b01c393476065c558b0Mathias Agopianvoid SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags) 11813d57964a81cd631d80aa9575647e1ce35b5e82d5Mathias Agopian{ 11823d57964a81cd631d80aa9575647e1ce35b5e82d5Mathias Agopian const LayerVector& currentLayers(mCurrentState.layersSortedByZ); 1183edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project const size_t count = currentLayers.size(); 1184edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1185edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project /* 1186edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project * Traversal of the children 1187edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project * (perform the transaction for each of them if needed) 1188edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project */ 1189edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 11903559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian if (transactionFlags & eTraversalNeeded) { 1191edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project for (size_t i=0 ; i<count ; i++) { 119213127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer(currentLayers[i]); 1193edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded); 1194edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project if (!trFlags) continue; 1195edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1196edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project const uint32_t flags = layer->doTransaction(0); 1197edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project if (flags & Layer::eVisibleRegion) 1198edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project mVisibleRegionsDirty = true; 1199edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1200edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1201edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1202edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project /* 12033559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian * Perform display own transactions if needed 1204edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project */ 1205edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1206e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (transactionFlags & eDisplayTransactionNeeded) { 120792a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // here we take advantage of Vector's copy-on-write semantics to 120892a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // improve performance by skipping the transaction entirely when 120992a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // know that the lists are identical 1210e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian const KeyedVector< wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays); 1211e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian const KeyedVector< wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays); 121292a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian if (!curr.isIdenticalTo(draw)) { 1213edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project mVisibleRegionsDirty = true; 121492a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian const size_t cc = curr.size(); 121593997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian size_t dc = draw.size(); 121692a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian 121792a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // find the displays that were removed 121892a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // (ie: in drawing state but not in current state) 121992a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // also handle displays that changed 122092a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // (ie: displays that are in both lists) 122192a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian for (size_t i=0 ; i<dc ; i++) { 1222e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian const ssize_t j = curr.indexOfKey(draw.keyAt(i)); 1223e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (j < 0) { 122492a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // in drawing state but not in current state 12253ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias Agopian if (!draw[i].isMainDisplay()) { 122627ec5739bc05330e08b02f25b62a8f597bad897aAndy McFadden // Call makeCurrent() on the primary display so we can 122727ec5739bc05330e08b02f25b62a8f597bad897aAndy McFadden // be sure that nothing associated with this display 122827ec5739bc05330e08b02f25b62a8f597bad897aAndy McFadden // is current. 122902d86567d95b99e1142941ed7ec23a4465822813Jesse Hall const sp<const DisplayDevice> defaultDisplay(getDefaultDisplayDevice()); 1230875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian defaultDisplay->makeCurrent(mEGLDisplay, mEGLContext); 123102d86567d95b99e1142941ed7ec23a4465822813Jesse Hall sp<DisplayDevice> hw(getDisplayDevice(draw.keyAt(i))); 123202d86567d95b99e1142941ed7ec23a4465822813Jesse Hall if (hw != NULL) 123302d86567d95b99e1142941ed7ec23a4465822813Jesse Hall hw->disconnect(getHwComposer()); 12349e663de4fe1dcc872373ee530c60a375624671c3Jesse Hall if (draw[i].type < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) 12357adb0f8a9fdb961692ffd2f0c65cacb155143f64Jesse Hall mEventThread->onHotplugReceived(draw[i].type, false); 123602d86567d95b99e1142941ed7ec23a4465822813Jesse Hall mDisplays.removeItem(draw.keyAt(i)); 123792a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } else { 123892a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian ALOGW("trying to remove the main display"); 123992a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } 124092a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } else { 124192a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // this display is in both lists. see if something changed. 1242e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian const DisplayDeviceState& state(curr[j]); 12433ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias Agopian const wp<IBinder>& display(curr.keyAt(j)); 1244111b2d89221722d38f5b5b3ba65904ec22421839Mathias Agopian if (state.surface->asBinder() != draw[i].surface->asBinder()) { 1245e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian // changing the surface is like destroying and 124693997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian // recreating the DisplayDevice, so we just remove it 124793997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian // from the drawing state, so that it get re-added 124893997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian // below. 124902d86567d95b99e1142941ed7ec23a4465822813Jesse Hall sp<DisplayDevice> hw(getDisplayDevice(display)); 125002d86567d95b99e1142941ed7ec23a4465822813Jesse Hall if (hw != NULL) 125102d86567d95b99e1142941ed7ec23a4465822813Jesse Hall hw->disconnect(getHwComposer()); 125293997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian mDisplays.removeItem(display); 125393997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian mDrawingState.displays.removeItemsAt(i); 125493997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian dc--; i--; 125593997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian // at this point we must loop to the next item 125693997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian continue; 125792a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } 125893997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian 1259db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian const sp<DisplayDevice> disp(getDisplayDevice(display)); 126093997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian if (disp != NULL) { 126193997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian if (state.layerStack != draw[i].layerStack) { 126293997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian disp->setLayerStack(state.layerStack); 126393997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian } 126400e8c7a88a5b9c4104a71013a713acd3e4d3b77bMathias Agopian if ((state.orientation != draw[i].orientation) 126500e8c7a88a5b9c4104a71013a713acd3e4d3b77bMathias Agopian || (state.viewport != draw[i].viewport) 126600e8c7a88a5b9c4104a71013a713acd3e4d3b77bMathias Agopian || (state.frame != draw[i].frame)) 126700e8c7a88a5b9c4104a71013a713acd3e4d3b77bMathias Agopian { 126800e8c7a88a5b9c4104a71013a713acd3e4d3b77bMathias Agopian disp->setProjection(state.orientation, 12694fb3999cea652617be5125f8a42c257467bf3c77Jeff Brown state.viewport, state.frame); 127093997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian } 127192a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } 127292a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } 127392a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } 127492a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian 127592a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // find displays that were added 127692a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian // (ie: in current state but not in drawing state) 127792a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian for (size_t i=0 ; i<cc ; i++) { 1278e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (draw.indexOfKey(curr.keyAt(i)) < 0) { 1279e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian const DisplayDeviceState& state(curr[i]); 1280cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian 128199c7dbb24994df2f3e175f7b25dd2c9dd92a72f0Jesse Hall sp<DisplaySurface> dispSurface; 1282db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian sp<IGraphicBufferProducer> producer; 1283db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian sp<BufferQueue> bq = new BufferQueue(new GraphicBufferAlloc()); 1284db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian 128502d86567d95b99e1142941ed7ec23a4465822813Jesse Hall int32_t hwcDisplayId = -1; 128699c7dbb24994df2f3e175f7b25dd2c9dd92a72f0Jesse Hall if (state.isVirtualDisplay()) { 128702d86567d95b99e1142941ed7ec23a4465822813Jesse Hall // Virtual displays without a surface are dormant: 128802d86567d95b99e1142941ed7ec23a4465822813Jesse Hall // they have external state (layer stack, projection, 128902d86567d95b99e1142941ed7ec23a4465822813Jesse Hall // etc.) but no internal state (i.e. a DisplayDevice). 129099c7dbb24994df2f3e175f7b25dd2c9dd92a72f0Jesse Hall if (state.surface != NULL) { 1291db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian 129202d86567d95b99e1142941ed7ec23a4465822813Jesse Hall hwcDisplayId = allocateHwcDisplayId(state.type); 1293db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian sp<VirtualDisplaySurface> vds = new VirtualDisplaySurface( 1294db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian *mHwc, hwcDisplayId, state.surface, bq, 129599c7dbb24994df2f3e175f7b25dd2c9dd92a72f0Jesse Hall state.displayName); 1296db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian 1297db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian dispSurface = vds; 1298db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian if (hwcDisplayId >= 0) { 1299db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian producer = vds; 1300db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian } else { 1301db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian // There won't be any interaction with HWC for this virtual display, 1302db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian // so the GLES driver can pass buffers directly to the sink. 1303db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian producer = state.surface; 1304db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian } 130599c7dbb24994df2f3e175f7b25dd2c9dd92a72f0Jesse Hall } 130699c7dbb24994df2f3e175f7b25dd2c9dd92a72f0Jesse Hall } else { 1307cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian ALOGE_IF(state.surface!=NULL, 1308cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian "adding a supported display, but rendering " 1309cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian "surface is provided (%p), ignoring it", 1310cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian state.surface.get()); 131102d86567d95b99e1142941ed7ec23a4465822813Jesse Hall hwcDisplayId = allocateHwcDisplayId(state.type); 1312cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian // for supported (by hwc) displays we provide our 1313cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian // own rendering surface 1314db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian dispSurface = new FramebufferSurface(*mHwc, state.type, bq); 1315db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian producer = bq; 1316cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian } 1317cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian 1318cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian const wp<IBinder>& display(curr.keyAt(i)); 131999c7dbb24994df2f3e175f7b25dd2c9dd92a72f0Jesse Hall if (dispSurface != NULL) { 1320cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian sp<DisplayDevice> hw = new DisplayDevice(this, 1321ffe1f19ca9707f84cb9fdb06209bf36cd8c2ef0aJesse Hall state.type, hwcDisplayId, state.isSecure, 1322db89edc94bd2a78226b407f9f7261e202e7fa325Mathias Agopian display, dispSurface, producer, mEGLConfig); 1323cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian hw->setLayerStack(state.layerStack); 1324cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian hw->setProjection(state.orientation, 13254fb3999cea652617be5125f8a42c257467bf3c77Jeff Brown state.viewport, state.frame); 13268dfa92fef9759a881e96ee58d59875d35023aab9Andy McFadden hw->setDisplayName(state.displayName); 1327cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian mDisplays.add(display, hw); 13281c569c4d45f89ec05abf8f8fe3a560e68bf39a8eJesse Hall if (state.isVirtualDisplay()) { 13291c569c4d45f89ec05abf8f8fe3a560e68bf39a8eJesse Hall if (hwcDisplayId >= 0) { 13301c569c4d45f89ec05abf8f8fe3a560e68bf39a8eJesse Hall mHwc->setVirtualDisplayProperties(hwcDisplayId, 13311c569c4d45f89ec05abf8f8fe3a560e68bf39a8eJesse Hall hw->getWidth(), hw->getHeight(), 13321c569c4d45f89ec05abf8f8fe3a560e68bf39a8eJesse Hall hw->getFormat()); 13331c569c4d45f89ec05abf8f8fe3a560e68bf39a8eJesse Hall } 13341c569c4d45f89ec05abf8f8fe3a560e68bf39a8eJesse Hall } else { 13357adb0f8a9fdb961692ffd2f0c65cacb155143f64Jesse Hall mEventThread->onHotplugReceived(state.type, true); 13361c569c4d45f89ec05abf8f8fe3a560e68bf39a8eJesse Hall } 133793997a8a75942b4d06cf50925de5bede489cc134Mathias Agopian } 133892a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } 133992a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } 1340edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 13413559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian } 1342edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 13438430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian if (transactionFlags & (eTraversalNeeded|eDisplayTransactionNeeded)) { 13448430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // The transform hint might have changed for some layers 13458430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // (either because a display has changed, or because a layer 13468430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // as changed). 13478430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // 13488430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // Walk through all the layers in currentLayers, 13498430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // and update their transform hint. 13508430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // 13518430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // If a layer is visible only on a single display, then that 13528430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // display is used to calculate the hint, otherwise we use the 13538430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // default display. 13548430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // 13558430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // NOTE: we do this here, rather than in rebuildLayerStacks() so that 13568430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // the hint is set before we acquire a buffer from the surface texture. 13578430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // 13588430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // NOTE: layer transactions have taken place already, so we use their 13598430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // drawing state. However, SurfaceFlinger's own transaction has not 13608430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // happened yet, so we must use the current state layer list 13618430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // (soon to become the drawing state list). 13628430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // 13638430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian sp<const DisplayDevice> disp; 13648430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian uint32_t currentlayerStack = 0; 13658430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian for (size_t i=0; i<count; i++) { 13668430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // NOTE: we rely on the fact that layers are sorted by 13678430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // layerStack first (so we don't have to traverse the list 13688430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // of displays for every layer). 136913127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer(currentLayers[i]); 13701eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian uint32_t layerStack = layer->getDrawingState().layerStack; 13718430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian if (i==0 || currentlayerStack != layerStack) { 13728430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian currentlayerStack = layerStack; 13738430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // figure out if this layerstack is mirrored 13748430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // (more than one display) if so, pick the default display, 13758430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian // if not, pick the only display it's on. 13768430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian disp.clear(); 13778430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 13788430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian sp<const DisplayDevice> hw(mDisplays[dpy]); 13798430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian if (hw->getLayerStack() == currentlayerStack) { 13808430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian if (disp == NULL) { 13818430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian disp = hw; 13828430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian } else { 138391d25932b6651b20159a737da6140cf8a6aaaf08Chet Haase disp = NULL; 13848430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian break; 13858430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian } 13868430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian } 13878430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian } 13888430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian } 138991d25932b6651b20159a737da6140cf8a6aaaf08Chet Haase if (disp == NULL) { 139091d25932b6651b20159a737da6140cf8a6aaaf08Chet Haase // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to 139191d25932b6651b20159a737da6140cf8a6aaaf08Chet Haase // redraw after transform hint changes. See bug 8508397. 139291d25932b6651b20159a737da6140cf8a6aaaf08Chet Haase 139391d25932b6651b20159a737da6140cf8a6aaaf08Chet Haase // could be null when this layer is using a layerStack 139491d25932b6651b20159a737da6140cf8a6aaaf08Chet Haase // that is not visible on any display. Also can occur at 139591d25932b6651b20159a737da6140cf8a6aaaf08Chet Haase // screen off/on times. 139691d25932b6651b20159a737da6140cf8a6aaaf08Chet Haase disp = getDefaultDisplayDevice(); 13978430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian } 139891d25932b6651b20159a737da6140cf8a6aaaf08Chet Haase layer->updateTransformHint(disp); 13998430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian } 14008430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian } 14018430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian 14028430095879d2fa6878e68f8f12da4e704815ac09Mathias Agopian 14033559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian /* 14043559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian * Perform our own transaction if needed 14053559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian */ 1406edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 14071eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const LayerVector& layers(mDrawingState.layersSortedByZ); 14081eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian if (currentLayers.size() > layers.size()) { 14093559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian // layers have been added 14103559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian mVisibleRegionsDirty = true; 14113559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian } 14123559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian 14133559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian // some layers might have been removed, so 14143559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian // we need to update the regions they're exposing. 14153559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian if (mLayersRemoved) { 14163559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian mLayersRemoved = false; 14173559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian mVisibleRegionsDirty = true; 14181eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const size_t count = layers.size(); 14193559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian for (size_t i=0 ; i<count ; i++) { 14201eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const sp<Layer>& layer(layers[i]); 14213559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian if (currentLayers.indexOf(layer) < 0) { 14223559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian // this layer is not visible anymore 14233559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian // TODO: we could traverse the tree from front to back and 14243559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian // compute the actual visible region 14253559b07a885bcdff51a6dffb8e3a5ac5adf3a220Mathias Agopian // TODO: we could cache the transformed region 14261eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const Layer::State& s(layer->getDrawingState()); 14271501d54d63c55dc4e8f4c6eeaeac35aca6660ffcMathias Agopian Region visibleReg = s.transform.transform( 14281501d54d63c55dc4e8f4c6eeaeac35aca6660ffcMathias Agopian Region(Rect(s.active.w, s.active.h))); 14291501d54d63c55dc4e8f4c6eeaeac35aca6660ffcMathias Agopian invalidateLayerStack(s.layerStack, visibleReg); 14300aa758d64ac530833ce9a311b164c9175a7a054cMathias Agopian } 1431edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1432edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1433edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1434edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project commitTransaction(); 14354fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian} 14364fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian 14374fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopianvoid SurfaceFlinger::commitTransaction() 14384fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian{ 14394fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian if (!mLayersPendingRemoval.isEmpty()) { 14404fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian // Notify removed layers now that they can't be drawn from 14414fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian for (size_t i = 0; i < mLayersPendingRemoval.size(); i++) { 14424fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian mLayersPendingRemoval[i]->onRemoved(); 14434fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian } 14444fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian mLayersPendingRemoval.clear(); 14454fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian } 14464fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian 14474b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis // If this transaction is part of a window animation then the next frame 14484b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis // we composite should be considered an animation as well. 14494b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis mAnimCompositionPending = mAnimTransactionPending; 14504b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis 14514fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian mDrawingState = mCurrentState; 14522d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis mTransactionPending = false; 14532d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis mAnimTransactionPending = false; 14544fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian mTransactionCV.broadcast(); 1455edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1456edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1457edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Projectvoid SurfaceFlinger::computeVisibleRegions( 145887baae104a3e4c2059990b01c393476065c558b0Mathias Agopian const LayerVector& currentLayers, uint32_t layerStack, 145987baae104a3e4c2059990b01c393476065c558b0Mathias Agopian Region& outDirtyRegion, Region& outOpaqueRegion) 1460edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 1461841cde55549cea7a344a1705b18d57a0c6c8ec45Mathias Agopian ATRACE_CALL(); 1462841cde55549cea7a344a1705b18d57a0c6c8ec45Mathias Agopian 1463edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project Region aboveOpaqueLayers; 1464edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project Region aboveCoveredLayers; 1465edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project Region dirty; 1466edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 146787baae104a3e4c2059990b01c393476065c558b0Mathias Agopian outDirtyRegion.clear(); 1468edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1469edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project size_t i = currentLayers.size(); 1470edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project while (i--) { 147113127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer = currentLayers[i]; 1472edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1473edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project // start with the whole surface at its current location 14741eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const Layer::State& s(layer->getDrawingState()); 1475edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 147601e29054e672301e4adbbca15b3562a59a20f267Jesse Hall // only consider the layers on the given layer stack 147787baae104a3e4c2059990b01c393476065c558b0Mathias Agopian if (s.layerStack != layerStack) 147887baae104a3e4c2059990b01c393476065c558b0Mathias Agopian continue; 147987baae104a3e4c2059990b01c393476065c558b0Mathias Agopian 1480ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian /* 1481ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * opaqueRegion: area of a surface that is fully opaque. 1482ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian */ 1483edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project Region opaqueRegion; 1484ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian 1485ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian /* 1486ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * visibleRegion: area of a surface that is visible on screen 1487ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * and not fully transparent. This is essentially the layer's 1488ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * footprint minus the opaque regions above it. 1489ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * Areas covered by a translucent surface are considered visible. 1490ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian */ 1491edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project Region visibleRegion; 1492ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian 1493ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian /* 1494ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * coveredRegion: area of a surface that is covered by all 1495ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * visible regions above it (which includes the translucent areas). 1496ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian */ 1497edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project Region coveredRegion; 1498ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian 1499a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall /* 1500a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall * transparentRegion: area of a surface that is hinted to be completely 1501a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall * transparent. This is only used to tell when the layer has no visible 1502a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall * non-transparent regions and can be removed from the layer list. It 1503a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall * does not affect the visibleRegion of this layer or any layers 1504a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall * beneath it. The hint may not be correct if apps don't respect the 1505a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall * SurfaceView restrictions (which, sadly, some don't). 1506a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall */ 1507a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall Region transparentRegion; 1508a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall 1509ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian 1510ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian // handle hidden surfaces by setting the visible region to empty 1511da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian if (CC_LIKELY(layer->isVisible())) { 1512a67932fe6864ac346e7f78b86df11cf6c5344137Mathias Agopian const bool translucent = !layer->isOpaque(); 15135219a06d61ac4517506500363c5e8a5972dd7ac9Mathias Agopian Rect bounds(s.transform.transform(layer->computeBounds())); 1514edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project visibleRegion.set(bounds); 1515ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian if (!visibleRegion.isEmpty()) { 1516ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian // Remove the transparent area from the visible region 1517ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian if (translucent) { 15184fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian const Transform tr(s.transform); 15194fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian if (tr.transformed()) { 15204fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian if (tr.preserveRects()) { 15214fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian // transform the transparent region 15222ca79399b933935eb1b6c0ec1f746f8c4475369cMathias Agopian transparentRegion = tr.transform(s.activeTransparentRegion); 15234fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian } else { 15244fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian // transformation too complex, can't do the 15254fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian // transparent region optimization. 1526a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall transparentRegion.clear(); 15274fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian } 15284fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian } else { 15292ca79399b933935eb1b6c0ec1f746f8c4475369cMathias Agopian transparentRegion = s.activeTransparentRegion; 15304fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian } 1531ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian } 1532edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1533ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian // compute the opaque region 15344fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian const int32_t layerOrientation = s.transform.getOrientation(); 1535ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian if (s.alpha==255 && !translucent && 1536ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian ((layerOrientation & Transform::ROT_INVALID) == false)) { 1537ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian // the opaque region is the layer's footprint 1538ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian opaqueRegion = visibleRegion; 1539ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian } 1540edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1541edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1542edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1543ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian // Clip the covered region to the visible region 1544ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian coveredRegion = aboveCoveredLayers.intersect(visibleRegion); 1545ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian 1546ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian // Update aboveCoveredLayers for next (lower) layer 1547ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian aboveCoveredLayers.orSelf(visibleRegion); 1548ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian 1549edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project // subtract the opaque region covered by the layers above us 1550edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project visibleRegion.subtractSelf(aboveOpaqueLayers); 1551edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1552edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project // compute this layer's dirty region 1553edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project if (layer->contentDirty) { 1554edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project // we need to invalidate the whole region 1555edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project dirty = visibleRegion; 1556edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project // as well, as the old visible region 15574fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian dirty.orSelf(layer->visibleRegion); 1558edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project layer->contentDirty = false; 1559edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } else { 1560a8d44f75e1934072713371a2dcd143c63ffcbe0eMathias Agopian /* compute the exposed region: 1561ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * the exposed region consists of two components: 1562ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * 1) what's VISIBLE now and was COVERED before 1563ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * 2) what's EXPOSED now less what was EXPOSED before 1564ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * 1565ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * note that (1) is conservative, we start with the whole 1566ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * visible region but only keep what used to be covered by 1567ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * something -- which mean it may have been exposed. 1568ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * 1569ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * (2) handles areas that were not covered by anything but got 1570ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian * exposed because of a resize. 1571a8d44f75e1934072713371a2dcd143c63ffcbe0eMathias Agopian */ 1572ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian const Region newExposed = visibleRegion - coveredRegion; 15734fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian const Region oldVisibleRegion = layer->visibleRegion; 15744fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian const Region oldCoveredRegion = layer->coveredRegion; 1575ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian const Region oldExposed = oldVisibleRegion - oldCoveredRegion; 1576ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian dirty = (visibleRegion&oldCoveredRegion) | (newExposed-oldExposed); 1577edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1578edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project dirty.subtractSelf(aboveOpaqueLayers); 1579edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1580edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project // accumulate to the screen dirty region 158187baae104a3e4c2059990b01c393476065c558b0Mathias Agopian outDirtyRegion.orSelf(dirty); 1582edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1583ab02873e8f4e235b0db800521dd0c969ed38c0b9Mathias Agopian // Update aboveOpaqueLayers for next (lower) layer 1584edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project aboveOpaqueLayers.orSelf(opaqueRegion); 15858b42e8a5d87dcdc8ea31368ab88de49b72ab5432Andreas Huber 1586a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall // Store the visible region in screen space 1587edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project layer->setVisibleRegion(visibleRegion); 1588edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project layer->setCoveredRegion(coveredRegion); 1589a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall layer->setVisibleNonTransparentRegion( 1590a8026d21f3f2f09e3416cbd33c277fbd15d8cf4eJesse Hall visibleRegion.subtract(transparentRegion)); 1591edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1592edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 159387baae104a3e4c2059990b01c393476065c558b0Mathias Agopian outOpaqueRegion = aboveOpaqueLayers; 1594edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1595edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 159687baae104a3e4c2059990b01c393476065c558b0Mathias Agopianvoid SurfaceFlinger::invalidateLayerStack(uint32_t layerStack, 159787baae104a3e4c2059990b01c393476065c558b0Mathias Agopian const Region& dirty) { 159892a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 15994297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian const sp<DisplayDevice>& hw(mDisplays[dpy]); 16004297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian if (hw->getLayerStack() == layerStack) { 16014297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian hw->dirtyRegion.orSelf(dirty); 160292a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } 160392a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian } 160487baae104a3e4c2059990b01c393476065c558b0Mathias Agopian} 160587baae104a3e4c2059990b01c393476065c558b0Mathias Agopian 160687baae104a3e4c2059990b01c393476065c558b0Mathias Agopianvoid SurfaceFlinger::handlePageFlip() 1607edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 16084fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian Region dirtyRegion; 160999ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian 16104fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian bool visibleRegions = false; 16111eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const LayerVector& layers(mDrawingState.layersSortedByZ); 16121eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const size_t count = layers.size(); 16134fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian for (size_t i=0 ; i<count ; i++) { 16141eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const sp<Layer>& layer(layers[i]); 161587baae104a3e4c2059990b01c393476065c558b0Mathias Agopian const Region dirty(layer->latchBuffer(visibleRegions)); 16161eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const Layer::State& s(layer->getDrawingState()); 161787baae104a3e4c2059990b01c393476065c558b0Mathias Agopian invalidateLayerStack(s.layerStack, dirty); 16184fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian } 16194da751999358fffa4cefc4c8046dab72045925f6Mathias Agopian 16203b1d2b6b2bbfb5df46b1059ec52360974e6f1428Mathias Agopian mVisibleRegionsDirty |= visibleRegions; 1621edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1622edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1623ad456f9878ff7c176499e7b992f9ff1cb3e9cdeeMathias Agopianvoid SurfaceFlinger::invalidateHwcGeometry() 1624ad456f9878ff7c176499e7b992f9ff1cb3e9cdeeMathias Agopian{ 1625ad456f9878ff7c176499e7b992f9ff1cb3e9cdeeMathias Agopian mHwWorkListDirty = true; 1626ad456f9878ff7c176499e7b992f9ff1cb3e9cdeeMathias Agopian} 1627ad456f9878ff7c176499e7b992f9ff1cb3e9cdeeMathias Agopian 162899ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian 1629cd60f99aba9e750700a967db30b74a29145739cfMathias Agopianvoid SurfaceFlinger::doDisplayComposition(const sp<const DisplayDevice>& hw, 163087baae104a3e4c2059990b01c393476065c558b0Mathias Agopian const Region& inDirtyRegion) 1631edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 163287baae104a3e4c2059990b01c393476065c558b0Mathias Agopian Region dirtyRegion(inDirtyRegion); 163387baae104a3e4c2059990b01c393476065c558b0Mathias Agopian 1634b8a5560e1303cb10f5cd482af466fc04d2bdfcabMathias Agopian // compute the invalid region 16354297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian hw->swapRegion.orSelf(dirtyRegion); 1636edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 16374297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian uint32_t flags = hw->getFlags(); 16380f2f5ff75b7b48ceb64270655ee6b62d09bf4d00Mathias Agopian if (flags & DisplayDevice::SWAP_RECTANGLE) { 163929d06ac9a45e564b4f935b91067fc92c2d4c193dMathias Agopian // we can redraw only what's dirty, but since SWAP_RECTANGLE only 164029d06ac9a45e564b4f935b91067fc92c2d4c193dMathias Agopian // takes a rectangle, we must make sure to update that whole 164129d06ac9a45e564b4f935b91067fc92c2d4c193dMathias Agopian // rectangle in that case 16424297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian dirtyRegion.set(hw->swapRegion.bounds()); 1643edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } else { 16440f2f5ff75b7b48ceb64270655ee6b62d09bf4d00Mathias Agopian if (flags & DisplayDevice::PARTIAL_UPDATES) { 164529d06ac9a45e564b4f935b91067fc92c2d4c193dMathias Agopian // We need to redraw the rectangle that will be updated 1646df3ca30bf663cb8eed88ee3f16fb5e9a65dc00fcMathias Agopian // (pushed to the framebuffer). 164795a666b0e001ebf738418b89d8e8fd50b18110f8Mathias Agopian // This is needed because PARTIAL_UPDATES only takes one 16480f2f5ff75b7b48ceb64270655ee6b62d09bf4d00Mathias Agopian // rectangle instead of a region (see DisplayDevice::flip()) 16494297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian dirtyRegion.set(hw->swapRegion.bounds()); 1650edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } else { 165129d06ac9a45e564b4f935b91067fc92c2d4c193dMathias Agopian // we need to redraw everything (the whole screen) 16524297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian dirtyRegion.set(hw->bounds()); 16534297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian hw->swapRegion = dirtyRegion; 1654edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1655edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1656edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1657ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian if (CC_LIKELY(!mDaltonize)) { 1658ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian doComposeSurfaces(hw, dirtyRegion); 1659ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian } else { 1660ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian RenderEngine& engine(getRenderEngine()); 1661ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian engine.beginGroup(mDaltonizer()); 1662ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian doComposeSurfaces(hw, dirtyRegion); 1663ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian engine.endGroup(); 1664ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian } 1665edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 16669c6e297271ec9af9d974242d89cfa08cb6ceaa0aMathias Agopian // update the swap region and clear the dirty region 16674297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian hw->swapRegion.orSelf(dirtyRegion); 1668da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian 1669da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian // swap buffers (presentation) 1670da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian hw->swapBuffers(getHwComposer()); 1671edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1672edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1673cd60f99aba9e750700a967db30b74a29145739cfMathias Agopianvoid SurfaceFlinger::doComposeSurfaces(const sp<const DisplayDevice>& hw, const Region& dirty) 1674edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 16753f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian RenderEngine& engine(getRenderEngine()); 167685d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian const int32_t id = hw->getHwcDisplayId(); 16778630320433bd15aca239522e54e711ef6372ab07Mathias Agopian HWComposer& hwc(getHwComposer()); 16781e26087493ac0e7d7dc6dea8ad85cfef08b3271fMathias Agopian HWComposer::LayerListIterator cur = hwc.begin(id); 16791e26087493ac0e7d7dc6dea8ad85cfef08b3271fMathias Agopian const HWComposer::LayerListIterator end = hwc.end(id); 1680a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian 1681d05a17fbb3772051d287f1f8830a7f00964f7ec2Jesse Hall bool hasGlesComposition = hwc.hasGlesComposition(id); 168285d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian if (hasGlesComposition) { 1683875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian if (!hw->makeCurrent(mEGLDisplay, mEGLContext)) { 1684c8c71096195de0128e57574b1ddf685838ceb2f0Michael Chock ALOGW("DisplayDevice::makeCurrent failed. Aborting surface composition for display %s", 1685c8c71096195de0128e57574b1ddf685838ceb2f0Michael Chock hw->getDisplayName().string()); 1686c8c71096195de0128e57574b1ddf685838ceb2f0Michael Chock return; 1687c8c71096195de0128e57574b1ddf685838ceb2f0Michael Chock } 1688a350ff98692b3a50cad5cc93f9f83221242ca86aMathias Agopian 1689a2f4e56fec0fb36c4a370eb23d6e9dc57f250b59Mathias Agopian // Never touch the framebuffer if we don't have any framebuffer layers 169085d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian const bool hasHwcComposition = hwc.hasHwcComposition(id); 1691e60b0687c8d49871d0c8786cabe6851f7a7783b5Mathias Agopian if (hasHwcComposition) { 1692b9494d5c9d44e4a59b6d510fea1665de434f3c6bMathias Agopian // when using overlays, we assume a fully transparent framebuffer 1693b9494d5c9d44e4a59b6d510fea1665de434f3c6bMathias Agopian // NOTE: we could reduce how much we need to clear, for instance 1694b9494d5c9d44e4a59b6d510fea1665de434f3c6bMathias Agopian // remove where there are opaque FB layers. however, on some 16953f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian // GPUs doing a "clean slate" clear might be more efficient. 1696b9494d5c9d44e4a59b6d510fea1665de434f3c6bMathias Agopian // We'll revisit later if needed. 16973f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian engine.clearWithColor(0, 0, 0, 0); 1698b9494d5c9d44e4a59b6d510fea1665de434f3c6bMathias Agopian } else { 1699766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian // we start with the whole screen area 1700766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian const Region bounds(hw->getBounds()); 1701766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian 1702766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian // we remove the scissor part 1703766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian // we're left with the letterbox region 1704766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian // (common case is that letterbox ends-up being empty) 1705766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian const Region letterbox(bounds.subtract(hw->getScissor())); 1706766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian 1707766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian // compute the area to clear 1708766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian Region region(hw->undefinedRegion.merge(letterbox)); 1709766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian 1710766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian // but limit it to the dirty region 1711766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian region.andSelf(dirty); 1712766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian 1713b9494d5c9d44e4a59b6d510fea1665de434f3c6bMathias Agopian // screen is already cleared here 171487baae104a3e4c2059990b01c393476065c558b0Mathias Agopian if (!region.isEmpty()) { 1715b9494d5c9d44e4a59b6d510fea1665de434f3c6bMathias Agopian // can happen with SurfaceView 171655801e41e6d7306d75d8134dd69d7d8cbbfbc63cMathias Agopian drawWormhole(hw, region); 1717b9494d5c9d44e4a59b6d510fea1665de434f3c6bMathias Agopian } 1718a2f4e56fec0fb36c4a370eb23d6e9dc57f250b59Mathias Agopian } 1719f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian 1720766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian if (hw->getDisplayType() != DisplayDevice::DISPLAY_PRIMARY) { 1721766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian // just to be on the safe side, we don't set the 1722f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian // scissor on the main display. It should never be needed 1723f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian // anyways (though in theory it could since the API allows it). 1724f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian const Rect& bounds(hw->getBounds()); 1725766dc49c17dda977bf7b93a5fd8da41c0b737611Mathias Agopian const Rect& scissor(hw->getScissor()); 1726f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian if (scissor != bounds) { 1727f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian // scissor doesn't match the screen's dimensions, so we 1728f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian // need to clear everything outside of it and enable 1729f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian // the GL scissor so we don't draw anything where we shouldn't 17303f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian 1731f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian // enable scissor for this frame 17323f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian const uint32_t height = hw->getHeight(); 17333f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian engine.setScissor(scissor.left, height - scissor.bottom, 17343f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian scissor.getWidth(), scissor.getHeight()); 1735f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian } 1736f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian } 173785d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian } 17384b2ba53423ac2dc795a5a0bf72f6d787d9dc8950Mathias Agopian 173985d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian /* 174085d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian * and then, render the layers targeted at the framebuffer 174185d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian */ 17424b2ba53423ac2dc795a5a0bf72f6d787d9dc8950Mathias Agopian 174313127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const Vector< sp<Layer> >& layers(hw->getVisibleLayersSortedByZ()); 174485d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian const size_t count = layers.size(); 174585d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian const Transform& tr = hw->getTransform(); 174685d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian if (cur != end) { 174785d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian // we're using h/w composer 174885d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian for (size_t i=0 ; i<count && cur!=end ; ++i, ++cur) { 174913127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer(layers[i]); 17504fec873a98f7b4380720cd1ad006f74c8cdc73daMathias Agopian const Region clip(dirty.intersect(tr.transform(layer->visibleRegion))); 175185d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian if (!clip.isEmpty()) { 175285d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian switch (cur->getCompositionType()) { 175385d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian case HWC_OVERLAY: { 1754ac68302e1cde8b931073929311fd6654a3253fc7Mathias Agopian const Layer::State& state(layer->getDrawingState()); 175585d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian if ((cur->getHints() & HWC_HINT_CLEAR_FB) 175685d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian && i 1757ac68302e1cde8b931073929311fd6654a3253fc7Mathias Agopian && layer->isOpaque() && (state.alpha == 0xFF) 175885d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian && hasGlesComposition) { 1759cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian // never clear the very first layer since we're 1760cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian // guaranteed the FB is already cleared 1761cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian layer->clearWithOpenGL(hw, clip); 1762cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } 176385d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian break; 176485d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian } 176585d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian case HWC_FRAMEBUFFER: { 1766cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian layer->draw(hw, clip); 176785d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian break; 1768a2f4e56fec0fb36c4a370eb23d6e9dc57f250b59Mathias Agopian } 1769da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian case HWC_FRAMEBUFFER_TARGET: { 1770da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian // this should not happen as the iterator shouldn't 1771da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian // let us get there. 1772da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian ALOGW("HWC_FRAMEBUFFER_TARGET found in hwc list (index=%d)", i); 1773da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian break; 1774da27af9832a0170f1fc40ef3f21371c4d30d21b3Mathias Agopian } 1775cd60f99aba9e750700a967db30b74a29145739cfMathias Agopian } 1776a6b32db164e7834e211261046f3229bf50bc0098Jesse Hall } 177785d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian layer->setAcquireFence(hw, *cur); 177885d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian } 177985d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian } else { 178085d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian // we're not using h/w composer 178185d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian for (size_t i=0 ; i<count ; ++i) { 178213127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer(layers[i]); 178385d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian const Region clip(dirty.intersect( 178485d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian tr.transform(layer->visibleRegion))); 178585d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian if (!clip.isEmpty()) { 178685d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian layer->draw(hw, clip); 178785d751cba5d4386c739dbf9dd8f7bbf8c493ade9Mathias Agopian } 17884b2ba53423ac2dc795a5a0bf72f6d787d9dc8950Mathias Agopian } 17894b2ba53423ac2dc795a5a0bf72f6d787d9dc8950Mathias Agopian } 1790f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian 1791f45c510009edab4a3e93f8d66b2e30aa26759fedMathias Agopian // disable scissor at the end of the frame 17923f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian engine.disableScissor(); 1793edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1794edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 17953f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopianvoid SurfaceFlinger::drawWormhole(const sp<const DisplayDevice>& hw, const Region& region) const { 179655801e41e6d7306d75d8134dd69d7d8cbbfbc63cMathias Agopian const int32_t height = hw->getHeight(); 17973f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian RenderEngine& engine(getRenderEngine()); 17983f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian engine.fillRegionWithColor(region, height, 0, 0, 0, 0); 1799edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1800edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1801ac9fa427d4a86745e60a5f7fd8e3ea340c4db907Mathias Agopianvoid SurfaceFlinger::addClientLayer(const sp<Client>& client, 1802ac9fa427d4a86745e60a5f7fd8e3ea340c4db907Mathias Agopian const sp<IBinder>& handle, 18036710604286401d4205c27235a252dd0e5008cc08Mathias Agopian const sp<IGraphicBufferProducer>& gbc, 180413127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& lbc) 18051b5e1021b8c9b87113b70d94dfb7b50f8c5b01b8Mathias Agopian{ 180696f0819f81293076e652792794a961543e6750d7Mathias Agopian // attach this layer to the client 1807ac9fa427d4a86745e60a5f7fd8e3ea340c4db907Mathias Agopian client->attachLayer(handle, lbc); 18084f113740180b6512b43723c4728f262882dc9b45Mathias Agopian 180996f0819f81293076e652792794a961543e6750d7Mathias Agopian // add this layer to the current state list 1810921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian Mutex::Autolock _l(mStateLock); 1811921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian mCurrentState.layersSortedByZ.add(lbc); 18126710604286401d4205c27235a252dd0e5008cc08Mathias Agopian mGraphicBufferProducerList.add(gbc->asBinder()); 181396f0819f81293076e652792794a961543e6750d7Mathias Agopian} 181496f0819f81293076e652792794a961543e6750d7Mathias Agopian 18153f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopianstatus_t SurfaceFlinger::removeLayer(const sp<Layer>& layer) { 181696f0819f81293076e652792794a961543e6750d7Mathias Agopian Mutex::Autolock _l(mStateLock); 181713127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian ssize_t index = mCurrentState.layersSortedByZ.remove(layer); 1818edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project if (index >= 0) { 18196710604286401d4205c27235a252dd0e5008cc08Mathias Agopian mLayersPendingRemoval.push(layer); 1820076b1cc3a9b90aa5b381a1ed268ca0b548444c9bMathias Agopian mLayersRemoved = true; 18216710604286401d4205c27235a252dd0e5008cc08Mathias Agopian setTransactionFlags(eTransactionNeeded); 1822edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project return NO_ERROR; 1823edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 18243d57964a81cd631d80aa9575647e1ce35b5e82d5Mathias Agopian return status_t(index); 1825edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1826edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 18273f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopianuint32_t SurfaceFlinger::peekTransactionFlags(uint32_t flags) { 1828dea20b1f343012d58ca9eb381684b26a168dc127Mathias Agopian return android_atomic_release_load(&mTransactionFlags); 1829dea20b1f343012d58ca9eb381684b26a168dc127Mathias Agopian} 1830dea20b1f343012d58ca9eb381684b26a168dc127Mathias Agopian 18313f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopianuint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags) { 1832edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project return android_atomic_and(~flags, &mTransactionFlags) & flags; 1833edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1834edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 18353f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopianuint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags) { 1836edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project uint32_t old = android_atomic_or(flags, &mTransactionFlags); 1837edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project if ((old & flags)==0) { // wake the server up 183899ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian signalTransaction(); 1839edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1840edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project return old; 1841edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1842edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 18438b33f032327f8de0dcc0e6d0d43ed80f834b51f6Mathias Agopianvoid SurfaceFlinger::setTransactionState( 18448b33f032327f8de0dcc0e6d0d43ed80f834b51f6Mathias Agopian const Vector<ComposerState>& state, 18458b33f032327f8de0dcc0e6d0d43ed80f834b51f6Mathias Agopian const Vector<DisplayState>& displays, 18468b33f032327f8de0dcc0e6d0d43ed80f834b51f6Mathias Agopian uint32_t flags) 18478b33f032327f8de0dcc0e6d0d43ed80f834b51f6Mathias Agopian{ 18487c41bf7092b75dba6029cd3bbc842d3a2661b0aaJamie Gennis ATRACE_CALL(); 1849698c0873cf2e07bdc7fd1e72169aee2a19fa40d7Mathias Agopian Mutex::Autolock _l(mStateLock); 185028378392fd5aa3e0a392c9eb64634055678c3987Jamie Gennis uint32_t transactionFlags = 0; 1851e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian 18522d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis if (flags & eAnimation) { 18532d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis // For window updates that are part of an animation we must wait for 18542d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis // previous animation "frames" to be handled. 18552d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis while (mAnimTransactionPending) { 18567c41bf7092b75dba6029cd3bbc842d3a2661b0aaJamie Gennis status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5)); 18572d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis if (CC_UNLIKELY(err != NO_ERROR)) { 18582d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis // just in case something goes wrong in SF, return to the 18597c41bf7092b75dba6029cd3bbc842d3a2661b0aaJamie Gennis // caller after a few seconds. 18607c41bf7092b75dba6029cd3bbc842d3a2661b0aaJamie Gennis ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out " 18617c41bf7092b75dba6029cd3bbc842d3a2661b0aaJamie Gennis "waiting for previous animation frame"); 18622d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis mAnimTransactionPending = false; 18632d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis break; 18642d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis } 18652d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis } 18662d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis } 18672d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis 1868e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian size_t count = displays.size(); 1869e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian for (size_t i=0 ; i<count ; i++) { 1870e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian const DisplayState& s(displays[i]); 1871e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian transactionFlags |= setDisplayStateLocked(s); 1872b8d69a55f1c187a35ac41e69de63251f5501b6f4Jamie Gennis } 1873b8d69a55f1c187a35ac41e69de63251f5501b6f4Jamie Gennis 1874e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian count = state.size(); 1875698c0873cf2e07bdc7fd1e72169aee2a19fa40d7Mathias Agopian for (size_t i=0 ; i<count ; i++) { 1876698c0873cf2e07bdc7fd1e72169aee2a19fa40d7Mathias Agopian const ComposerState& s(state[i]); 1877d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian // Here we need to check that the interface we're given is indeed 1878d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian // one of our own. A malicious client could give us a NULL 1879d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian // IInterface, or one of its own or even one of our own but a 1880d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian // different type. All these situations would cause us to crash. 1881d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian // 1882d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian // NOTE: it would be better to use RTTI as we could directly check 1883d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian // that we have a Client*. however, RTTI is disabled in Android. 1884d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian if (s.client != NULL) { 1885d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian sp<IBinder> binder = s.client->asBinder(); 1886d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian if (binder != NULL) { 1887d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian String16 desc(binder->getInterfaceDescriptor()); 1888d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian if (desc == ISurfaceComposerClient::descriptor) { 1889d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian sp<Client> client( static_cast<Client *>(s.client.get()) ); 1890d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian transactionFlags |= setClientStateLocked(client, s.state); 1891d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian } 1892d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian } 1893d17e3b5f6cf71eb52bc81f37719254ce08244b34Mathias Agopian } 1894698c0873cf2e07bdc7fd1e72169aee2a19fa40d7Mathias Agopian } 1895386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian 189628378392fd5aa3e0a392c9eb64634055678c3987Jamie Gennis if (transactionFlags) { 1897386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian // this triggers the transaction 189828378392fd5aa3e0a392c9eb64634055678c3987Jamie Gennis setTransactionFlags(transactionFlags); 1899698c0873cf2e07bdc7fd1e72169aee2a19fa40d7Mathias Agopian 1900386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian // if this is a synchronous transaction, wait for it to take effect 1901386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian // before returning. 1902386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian if (flags & eSynchronous) { 19032d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis mTransactionPending = true; 19042d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis } 19052d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis if (flags & eAnimation) { 19062d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis mAnimTransactionPending = true; 1907386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian } 19082d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis while (mTransactionPending) { 1909386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5)); 1910386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian if (CC_UNLIKELY(err != NO_ERROR)) { 1911386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian // just in case something goes wrong in SF, return to the 1912386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian // called after a few seconds. 19132d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!"); 19142d5e230292c27d59f4c096bc742a0a19abf811c1Jamie Gennis mTransactionPending = false; 1915386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian break; 1916386aa98c4ffb9b805303e683f0a7b925b44d04dbMathias Agopian } 1917cbb288bfe89f585bf48371bd31b2d4aafa32f32eMathias Agopian } 1918edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 1919edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 1920edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 1921e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopianuint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s) 1922e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian{ 19239a14392256354538f1f43a5e80fe46c2c2b965cbJesse Hall ssize_t dpyIdx = mCurrentState.displays.indexOfKey(s.token); 19249a14392256354538f1f43a5e80fe46c2c2b965cbJesse Hall if (dpyIdx < 0) 19259a14392256354538f1f43a5e80fe46c2c2b965cbJesse Hall return 0; 19269a14392256354538f1f43a5e80fe46c2c2b965cbJesse Hall 1927e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian uint32_t flags = 0; 19289a14392256354538f1f43a5e80fe46c2c2b965cbJesse Hall DisplayDeviceState& disp(mCurrentState.displays.editValueAt(dpyIdx)); 19293ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias Agopian if (disp.isValid()) { 1930e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian const uint32_t what = s.what; 1931e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (what & DisplayState::eSurfaceChanged) { 1932e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (disp.surface->asBinder() != s.surface->asBinder()) { 1933e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian disp.surface = s.surface; 1934e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eDisplayTransactionNeeded; 1935e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 1936e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 1937e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (what & DisplayState::eLayerStackChanged) { 1938e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (disp.layerStack != s.layerStack) { 1939e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian disp.layerStack = s.layerStack; 1940e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eDisplayTransactionNeeded; 1941e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 1942e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 194300e8c7a88a5b9c4104a71013a713acd3e4d3b77bMathias Agopian if (what & DisplayState::eDisplayProjectionChanged) { 1944e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (disp.orientation != s.orientation) { 1945e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian disp.orientation = s.orientation; 1946e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eDisplayTransactionNeeded; 1947e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 1948e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (disp.frame != s.frame) { 1949e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian disp.frame = s.frame; 1950e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eDisplayTransactionNeeded; 1951e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 1952e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (disp.viewport != s.viewport) { 1953e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian disp.viewport = s.viewport; 1954e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eDisplayTransactionNeeded; 1955e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 1956e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 1957e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 1958e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian return flags; 1959e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian} 1960e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian 1961e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopianuint32_t SurfaceFlinger::setClientStateLocked( 1962e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian const sp<Client>& client, 1963e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian const layer_state_t& s) 1964e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian{ 1965e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian uint32_t flags = 0; 196613127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian sp<Layer> layer(client->getLayerUser(s.surface)); 1967e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (layer != 0) { 1968e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian const uint32_t what = s.what; 1969e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (what & layer_state_t::ePositionChanged) { 1970e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (layer->setPosition(s.x, s.y)) 1971e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eTraversalNeeded; 1972e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 1973e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (what & layer_state_t::eLayerChanged) { 1974e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian // NOTE: index needs to be calculated before we update the state 1975e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer); 1976e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (layer->setLayer(s.z)) { 1977e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian mCurrentState.layersSortedByZ.removeAt(idx); 1978e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian mCurrentState.layersSortedByZ.add(layer); 1979e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian // we need traversal (state changed) 1980e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian // AND transaction (list changed) 1981e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eTransactionNeeded|eTraversalNeeded; 1982e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 1983e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 1984e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (what & layer_state_t::eSizeChanged) { 1985e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (layer->setSize(s.w, s.h)) { 1986e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eTraversalNeeded; 1987e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 1988e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 1989e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (what & layer_state_t::eAlphaChanged) { 1990e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (layer->setAlpha(uint8_t(255.0f*s.alpha+0.5f))) 1991e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eTraversalNeeded; 1992e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 1993e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (what & layer_state_t::eMatrixChanged) { 1994e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (layer->setMatrix(s.matrix)) 1995e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eTraversalNeeded; 1996e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 1997e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (what & layer_state_t::eTransparentRegionChanged) { 1998e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (layer->setTransparentRegionHint(s.transparentRegion)) 1999e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eTraversalNeeded; 2000e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2001e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (what & layer_state_t::eVisibilityChanged) { 2002e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (layer->setFlags(s.flags, s.mask)) 2003e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eTraversalNeeded; 2004e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2005e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (what & layer_state_t::eCropChanged) { 2006e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (layer->setCrop(s.crop)) 2007e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eTraversalNeeded; 2008e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2009e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (what & layer_state_t::eLayerStackChanged) { 2010e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian // NOTE: index needs to be calculated before we update the state 2011e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer); 2012e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian if (layer->setLayerStack(s.layerStack)) { 2013e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian mCurrentState.layersSortedByZ.removeAt(idx); 2014e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian mCurrentState.layersSortedByZ.add(layer); 2015e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian // we need traversal (state changed) 2016e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian // AND transaction (list changed) 2017e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian flags |= eTransactionNeeded|eTraversalNeeded; 2018e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2019e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2020e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian } 2021e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian return flags; 2022e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian} 2023e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian 20244d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopianstatus_t SurfaceFlinger::createLayer( 20250ef4e15a6c12778daf464a4953d7e15e651f49acMathias Agopian const String8& name, 20260ef4e15a6c12778daf464a4953d7e15e651f49acMathias Agopian const sp<Client>& client, 20274d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian uint32_t w, uint32_t h, PixelFormat format, uint32_t flags, 20284d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp) 2029edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 20304d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian //ALOGD("createLayer for (%d x %d), name=%s", w, h, name.string()); 20316e2d6483fe14362187c78c91dc03024fbb31d431Mathias Agopian if (int32_t(w|h) < 0) { 2032921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)", 20336e2d6483fe14362187c78c91dc03024fbb31d431Mathias Agopian int(w), int(h)); 20344d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian return BAD_VALUE; 20356e2d6483fe14362187c78c91dc03024fbb31d431Mathias Agopian } 20368b42e8a5d87dcdc8ea31368ab88de49b72ab5432Andreas Huber 20374d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian status_t result = NO_ERROR; 20384d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian 20394d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian sp<Layer> layer; 20404d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian 20413165cc21cfea781988407b19bd83292b19f05f55Mathias Agopian switch (flags & ISurfaceComposerClient::eFXSurfaceMask) { 20423165cc21cfea781988407b19bd83292b19f05f55Mathias Agopian case ISurfaceComposerClient::eFXSurfaceNormal: 20434d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian result = createNormalLayer(client, 20444d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian name, w, h, flags, format, 20454d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian handle, gbp, &layer); 2046edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project break; 20473165cc21cfea781988407b19bd83292b19f05f55Mathias Agopian case ISurfaceComposerClient::eFXSurfaceDim: 20484d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian result = createDimLayer(client, 20494d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian name, w, h, flags, 20504d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian handle, gbp, &layer); 20514d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian break; 20524d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian default: 20534d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian result = BAD_VALUE; 2054edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project break; 2055edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 2056edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 20574d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian if (result == NO_ERROR) { 20586710604286401d4205c27235a252dd0e5008cc08Mathias Agopian addClientLayer(client, *handle, *gbp, layer); 205996f0819f81293076e652792794a961543e6750d7Mathias Agopian setTransactionFlags(eTransactionNeeded); 2060edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 20614d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian return result; 2062edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 2063edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 20644d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopianstatus_t SurfaceFlinger::createNormalLayer(const sp<Client>& client, 20654d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian const String8& name, uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format, 20664d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer) 2067edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 2068edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project // initialize the surfaces 206992a979a92c34b7de609ce2b1662c73bb8a2728b9Mathias Agopian switch (format) { 2070edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project case PIXEL_FORMAT_TRANSPARENT: 2071edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project case PIXEL_FORMAT_TRANSLUCENT: 2072edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project format = PIXEL_FORMAT_RGBA_8888; 2073edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project break; 2074edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project case PIXEL_FORMAT_OPAQUE: 2075a8f3e4e53cad835d0d57b85a6ce1b7416e95ba73Mathias Agopian#ifdef NO_RGBX_8888 2076a8f3e4e53cad835d0d57b85a6ce1b7416e95ba73Mathias Agopian format = PIXEL_FORMAT_RGB_565; 2077a8f3e4e53cad835d0d57b85a6ce1b7416e95ba73Mathias Agopian#else 20788f10540cd59e980dcdb5a8f4f2dbec0d94177f5fMathias Agopian format = PIXEL_FORMAT_RGBX_8888; 2079a8f3e4e53cad835d0d57b85a6ce1b7416e95ba73Mathias Agopian#endif 2080edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project break; 2081edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 2082edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 2083a8f3e4e53cad835d0d57b85a6ce1b7416e95ba73Mathias Agopian#ifdef NO_RGBX_8888 2084a8f3e4e53cad835d0d57b85a6ce1b7416e95ba73Mathias Agopian if (format == PIXEL_FORMAT_RGBX_8888) 2085a8f3e4e53cad835d0d57b85a6ce1b7416e95ba73Mathias Agopian format = PIXEL_FORMAT_RGBA_8888; 2086a8f3e4e53cad835d0d57b85a6ce1b7416e95ba73Mathias Agopian#endif 2087a8f3e4e53cad835d0d57b85a6ce1b7416e95ba73Mathias Agopian 20884d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian *outLayer = new Layer(this, client, name, w, h, flags); 20894d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian status_t err = (*outLayer)->setBuffers(w, h, format, flags); 20904d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian if (err == NO_ERROR) { 20914d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian *handle = (*outLayer)->getHandle(); 20924d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian *gbp = (*outLayer)->getBufferQueue(); 2093edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 20944d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian 20954d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian ALOGE_IF(err, "createNormalLayer() failed (%s)", strerror(-err)); 20964d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian return err; 2097edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 2098edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 20994d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopianstatus_t SurfaceFlinger::createDimLayer(const sp<Client>& client, 21004d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian const String8& name, uint32_t w, uint32_t h, uint32_t flags, 21014d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer) 2102edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 21034d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian *outLayer = new LayerDim(this, client, name, w, h, flags); 21044d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian *handle = (*outLayer)->getHandle(); 21054d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian *gbp = (*outLayer)->getBufferQueue(); 21064d9b822e2c18142e55fe2611aa6cd7dc7d4a62c6Mathias Agopian return NO_ERROR; 2107118d0245ee0a3b107055782aa8b555404b6f0280Mathias Agopian} 2108118d0245ee0a3b107055782aa8b555404b6f0280Mathias Agopian 2109ac9fa427d4a86745e60a5f7fd8e3ea340c4db907Mathias Agopianstatus_t SurfaceFlinger::onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle) 21109a11206fe793363c0e8897b478cbe6ef8c52b543Mathias Agopian{ 21116710604286401d4205c27235a252dd0e5008cc08Mathias Agopian // called by the window manager when it wants to remove a Layer 21126710604286401d4205c27235a252dd0e5008cc08Mathias Agopian status_t err = NO_ERROR; 21136710604286401d4205c27235a252dd0e5008cc08Mathias Agopian sp<Layer> l(client->getLayerUser(handle)); 21146710604286401d4205c27235a252dd0e5008cc08Mathias Agopian if (l != NULL) { 21156710604286401d4205c27235a252dd0e5008cc08Mathias Agopian err = removeLayer(l); 21166710604286401d4205c27235a252dd0e5008cc08Mathias Agopian ALOGE_IF(err<0 && err != NAME_NOT_FOUND, 21176710604286401d4205c27235a252dd0e5008cc08Mathias Agopian "error removing layer=%p (%s)", l.get(), strerror(-err)); 21189a11206fe793363c0e8897b478cbe6ef8c52b543Mathias Agopian } 21199a11206fe793363c0e8897b478cbe6ef8c52b543Mathias Agopian return err; 21209a11206fe793363c0e8897b478cbe6ef8c52b543Mathias Agopian} 21219a11206fe793363c0e8897b478cbe6ef8c52b543Mathias Agopian 212213127d8921356dff794250e04208c3ed60b3a3dfMathias Agopianstatus_t SurfaceFlinger::onLayerDestroyed(const wp<Layer>& layer) 2123edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 21246710604286401d4205c27235a252dd0e5008cc08Mathias Agopian // called by ~LayerCleaner() when all references to the IBinder (handle) 21256710604286401d4205c27235a252dd0e5008cc08Mathias Agopian // are gone 2126ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian status_t err = NO_ERROR; 212713127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian sp<Layer> l(layer.promote()); 2128ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian if (l != NULL) { 21296710604286401d4205c27235a252dd0e5008cc08Mathias Agopian err = removeLayer(l); 2130e6f43ddce78d6846af12550ff9193c5c6fe5844bSteve Block ALOGE_IF(err<0 && err != NAME_NOT_FOUND, 2131ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian "error removing layer=%p (%s)", l.get(), strerror(-err)); 2132ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian } 2133ca4d3602c07837d0b2ac6878685a8e327b5f30f0Mathias Agopian return err; 2134edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 2135edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 2136b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian// --------------------------------------------------------------------------- 2137b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian 213813a082e160c2d1d8006b93a555a57035213d568bAndy McFaddenvoid SurfaceFlinger::onInitializeDisplays() { 213901e29054e672301e4adbbca15b3562a59a20f267Jesse Hall // reset screen orientation and use primary layer stack 214013a082e160c2d1d8006b93a555a57035213d568bAndy McFadden Vector<ComposerState> state; 214113a082e160c2d1d8006b93a555a57035213d568bAndy McFadden Vector<DisplayState> displays; 214213a082e160c2d1d8006b93a555a57035213d568bAndy McFadden DisplayState d; 214301e29054e672301e4adbbca15b3562a59a20f267Jesse Hall d.what = DisplayState::eDisplayProjectionChanged | 214401e29054e672301e4adbbca15b3562a59a20f267Jesse Hall DisplayState::eLayerStackChanged; 2145692c723e84e6f2747447d871d468ff50e5c73f19Jesse Hall d.token = mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY]; 214601e29054e672301e4adbbca15b3562a59a20f267Jesse Hall d.layerStack = 0; 214713a082e160c2d1d8006b93a555a57035213d568bAndy McFadden d.orientation = DisplayState::eOrientationDefault; 21484c05dd175ee3bd5119eecf368742b6510a8cfa6cJeff Brown d.frame.makeInvalid(); 21494c05dd175ee3bd5119eecf368742b6510a8cfa6cJeff Brown d.viewport.makeInvalid(); 215013a082e160c2d1d8006b93a555a57035213d568bAndy McFadden displays.add(d); 215113a082e160c2d1d8006b93a555a57035213d568bAndy McFadden setTransactionState(state, displays, 0); 2152cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian onScreenAcquired(getDefaultDisplayDevice()); 21536547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis 21546547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis const nsecs_t period = 21556547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY); 21566547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis mAnimFrameTracker.setDisplayRefreshPeriod(period); 215713a082e160c2d1d8006b93a555a57035213d568bAndy McFadden} 215813a082e160c2d1d8006b93a555a57035213d568bAndy McFadden 215913a082e160c2d1d8006b93a555a57035213d568bAndy McFaddenvoid SurfaceFlinger::initializeDisplays() { 216013a082e160c2d1d8006b93a555a57035213d568bAndy McFadden class MessageScreenInitialized : public MessageBase { 216113a082e160c2d1d8006b93a555a57035213d568bAndy McFadden SurfaceFlinger* flinger; 216213a082e160c2d1d8006b93a555a57035213d568bAndy McFadden public: 216313a082e160c2d1d8006b93a555a57035213d568bAndy McFadden MessageScreenInitialized(SurfaceFlinger* flinger) : flinger(flinger) { } 216413a082e160c2d1d8006b93a555a57035213d568bAndy McFadden virtual bool handler() { 216513a082e160c2d1d8006b93a555a57035213d568bAndy McFadden flinger->onInitializeDisplays(); 216613a082e160c2d1d8006b93a555a57035213d568bAndy McFadden return true; 216713a082e160c2d1d8006b93a555a57035213d568bAndy McFadden } 216813a082e160c2d1d8006b93a555a57035213d568bAndy McFadden }; 216913a082e160c2d1d8006b93a555a57035213d568bAndy McFadden sp<MessageBase> msg = new MessageScreenInitialized(this); 217013a082e160c2d1d8006b93a555a57035213d568bAndy McFadden postMessageAsync(msg); // we may be called from main thread, use async message 217113a082e160c2d1d8006b93a555a57035213d568bAndy McFadden} 217213a082e160c2d1d8006b93a555a57035213d568bAndy McFadden 217313a082e160c2d1d8006b93a555a57035213d568bAndy McFadden 2174cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopianvoid SurfaceFlinger::onScreenAcquired(const sp<const DisplayDevice>& hw) { 2175c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden ALOGD("Screen acquired, type=%d flinger=%p", hw->getDisplayType(), this); 2176c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden if (hw->isScreenAcquired()) { 2177c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden // this is expected, e.g. when power manager wakes up during boot 2178c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden ALOGD(" screen was previously acquired"); 2179c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden return; 2180c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden } 2181c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden 21824297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian hw->acquireScreen(); 2183c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden int32_t type = hw->getDisplayType(); 21849e663de4fe1dcc872373ee530c60a375624671c3Jesse Hall if (type < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) { 2185c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden // built-in display, tell the HWC 2186c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden getHwComposer().acquire(type); 2187c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden 2188c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden if (type == DisplayDevice::DISPLAY_PRIMARY) { 2189c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden // FIXME: eventthread only knows about the main display right now 2190c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden mEventThread->onScreenAcquired(); 2191faf77cce9d9ec0238d6999b3bd0d40c71ff403c5Jamie Gennis 2192948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall resyncToHardwareVsync(true); 2193c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden } 2194cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian } 219520128300e0cb7f459a60cfbcddb48190ce6545edMathias Agopian mVisibleRegionsDirty = true; 219620128300e0cb7f459a60cfbcddb48190ce6545edMathias Agopian repaintEverything(); 2197edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 2198edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 2199cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopianvoid SurfaceFlinger::onScreenReleased(const sp<const DisplayDevice>& hw) { 2200c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden ALOGD("Screen released, type=%d flinger=%p", hw->getDisplayType(), this); 2201c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden if (!hw->isScreenAcquired()) { 2202c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden ALOGD(" screen was previously released"); 2203c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden return; 2204c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden } 2205c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden 2206c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden hw->releaseScreen(); 2207c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden int32_t type = hw->getDisplayType(); 22089e663de4fe1dcc872373ee530c60a375624671c3Jesse Hall if (type < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) { 2209c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden if (type == DisplayDevice::DISPLAY_PRIMARY) { 2210948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall disableHardwareVsync(true); // also cancels any in-progress resync 2211948fe0ce74c13e1bbff233883c158519fa8fb293Jesse Hall 2212cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian // FIXME: eventthread only knows about the main display right now 2213cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian mEventThread->onScreenReleased(); 2214cde87a3b9d3f8dc15232d927b56ee9e5e520f58dMathias Agopian } 2215c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden 2216c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden // built-in display, tell the HWC 2217c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden getHwComposer().release(type); 2218b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian } 2219c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden mVisibleRegionsDirty = true; 2220c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFadden // from this point on, SF will stop drawing on this display 2221b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian} 2222b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian 2223c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFaddenvoid SurfaceFlinger::unblank(const sp<IBinder>& display) { 2224b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian class MessageScreenAcquired : public MessageBase { 2225db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian SurfaceFlinger& mFlinger; 2226db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian sp<IBinder> mDisplay; 2227b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian public: 2228db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian MessageScreenAcquired(SurfaceFlinger& flinger, 2229db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian const sp<IBinder>& disp) : mFlinger(flinger), mDisplay(disp) { } 2230b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian virtual bool handler() { 2231db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian const sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay)); 2232db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian if (hw == NULL) { 2233db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian ALOGE("Attempt to unblank null display %p", mDisplay.get()); 22349e663de4fe1dcc872373ee530c60a375624671c3Jesse Hall } else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) { 2235db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian ALOGW("Attempt to unblank virtual display"); 2236db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian } else { 2237db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian mFlinger.onScreenAcquired(hw); 2238db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian } 2239b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian return true; 2240b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian } 2241b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian }; 2242db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian sp<MessageBase> msg = new MessageScreenAcquired(*this, display); 2243db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian postMessageSync(msg); 2244edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 2245edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 2246c01a79d77b829e7de86ef137694e8ad708470ca1Andy McFaddenvoid SurfaceFlinger::blank(const sp<IBinder>& display) { 2247b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian class MessageScreenReleased : public MessageBase { 2248db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian SurfaceFlinger& mFlinger; 2249db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian sp<IBinder> mDisplay; 2250b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian public: 2251db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian MessageScreenReleased(SurfaceFlinger& flinger, 2252db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian const sp<IBinder>& disp) : mFlinger(flinger), mDisplay(disp) { } 2253b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian virtual bool handler() { 2254db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian const sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay)); 2255db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian if (hw == NULL) { 2256db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian ALOGE("Attempt to blank null display %p", mDisplay.get()); 22579e663de4fe1dcc872373ee530c60a375624671c3Jesse Hall } else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) { 2258db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian ALOGW("Attempt to blank virtual display"); 2259db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian } else { 2260db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian mFlinger.onScreenReleased(hw); 2261db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian } 2262b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian return true; 2263b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian } 2264b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian }; 2265db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian sp<MessageBase> msg = new MessageScreenReleased(*this, display); 2266db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian postMessageSync(msg); 2267b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian} 2268b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian 2269b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian// --------------------------------------------------------------------------- 2270b60314a12f3336b27d73920805ab07cbc498d857Mathias Agopian 2271edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Projectstatus_t SurfaceFlinger::dump(int fd, const Vector<String16>& args) 2272edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 2273edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project String8 result; 227499b49840d309727678b77403d6cc9f920111623fMathias Agopian 2275bd1153382e7a9d89922bea999a52ca21d46d6caaMathias Agopian IPCThreadState* ipc = IPCThreadState::self(); 2276bd1153382e7a9d89922bea999a52ca21d46d6caaMathias Agopian const int pid = ipc->getCallingPid(); 2277bd1153382e7a9d89922bea999a52ca21d46d6caaMathias Agopian const int uid = ipc->getCallingUid(); 2278bd1153382e7a9d89922bea999a52ca21d46d6caaMathias Agopian if ((uid != AID_SHELL) && 2279bd1153382e7a9d89922bea999a52ca21d46d6caaMathias Agopian !PermissionCache::checkPermission(sDump, pid, uid)) { 228074d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian result.appendFormat("Permission Denial: " 2281bd1153382e7a9d89922bea999a52ca21d46d6caaMathias Agopian "can't dump SurfaceFlinger from pid=%d, uid=%d\n", pid, uid); 2282edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } else { 22839795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian // Try to get the main lock, but don't insist if we can't 22849795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian // (this would indicate SF is stuck, but we want to be able to 22859795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian // print something in dumpsys). 22869795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian int retry = 3; 22879795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian while (mStateLock.tryLock()<0 && --retry>=0) { 22889795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian usleep(1000000); 22899795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian } 22909795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian const bool locked(retry >= 0); 22919795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian if (!locked) { 229274d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian result.append( 22939795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian "SurfaceFlinger appears to be unresponsive, " 22949795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian "dumping anyways (no locks held)\n"); 22959795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian } 22969795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian 229782d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian bool dumpAll = true; 229882d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian size_t index = 0; 229925e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian size_t numArgs = args.size(); 230025e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian if (numArgs) { 230125e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian if ((index < numArgs) && 230225e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian (args[index] == String16("--list"))) { 230325e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian index++; 230474d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian listLayersLocked(args, index, result); 230535aadd6be249da4bd4851692e6aff757c91b32a7Mathias Agopian dumpAll = false; 230625e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian } 230725e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian 230825e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian if ((index < numArgs) && 230925e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian (args[index] == String16("--latency"))) { 231082d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian index++; 231174d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian dumpStatsLocked(args, index, result); 231235aadd6be249da4bd4851692e6aff757c91b32a7Mathias Agopian dumpAll = false; 231382d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian } 231425e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian 231525e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian if ((index < numArgs) && 231625e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian (args[index] == String16("--latency-clear"))) { 231725e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian index++; 231874d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian clearStatsLocked(args, index, result); 231935aadd6be249da4bd4851692e6aff757c91b32a7Mathias Agopian dumpAll = false; 232025e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian } 2321edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 23221b5e1021b8c9b87113b70d94dfb7b50f8c5b01b8Mathias Agopian 232382d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian if (dumpAll) { 232474d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian dumpAllLocked(args, index, result); 232582d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian } 232648b888aab9fdcfba250722dffbdffe61f11c64f3Mathias Agopian 232782d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian if (locked) { 232882d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian mStateLock.unlock(); 232948b888aab9fdcfba250722dffbdffe61f11c64f3Mathias Agopian } 233082d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian } 233182d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian write(fd, result.string(), result.size()); 233282d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian return NO_ERROR; 233382d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian} 233448b888aab9fdcfba250722dffbdffe61f11c64f3Mathias Agopian 233525e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopianvoid SurfaceFlinger::listLayersLocked(const Vector<String16>& args, size_t& index, 233674d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian String8& result) const 233725e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian{ 233825e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian const LayerVector& currentLayers = mCurrentState.layersSortedByZ; 233925e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian const size_t count = currentLayers.size(); 234025e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian for (size_t i=0 ; i<count ; i++) { 234113127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer(currentLayers[i]); 234274d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian result.appendFormat("%s\n", layer->getName().string()); 234325e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian } 234425e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian} 234525e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian 234682d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopianvoid SurfaceFlinger::dumpStatsLocked(const Vector<String16>& args, size_t& index, 234774d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian String8& result) const 234882d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian{ 234982d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian String8 name; 235082d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian if (index < args.size()) { 235182d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian name = String8(args[index]); 235282d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian index++; 235382d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian } 235448b888aab9fdcfba250722dffbdffe61f11c64f3Mathias Agopian 23554b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis const nsecs_t period = 23564b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY); 23574b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis result.appendFormat("%lld\n", period); 23584b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis 23594b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis if (name.isEmpty()) { 23604b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis mAnimFrameTracker.dump(result); 23614b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis } else { 23624b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis const LayerVector& currentLayers = mCurrentState.layersSortedByZ; 23634b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis const size_t count = currentLayers.size(); 23644b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis for (size_t i=0 ; i<count ; i++) { 236513127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer(currentLayers[i]); 23664b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis if (name == layer->getName()) { 236774d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian layer->dumpStats(result); 23684b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis } 236982d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian } 237082d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian } 237182d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian} 2372ad70186f80355e55ddad2a66b5fd174a1c019c2dMathias Agopian 237325e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopianvoid SurfaceFlinger::clearStatsLocked(const Vector<String16>& args, size_t& index, 237474d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian String8& result) 237525e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian{ 237625e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian String8 name; 237725e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian if (index < args.size()) { 237825e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian name = String8(args[index]); 237925e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian index++; 238025e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian } 238125e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian 238225e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian const LayerVector& currentLayers = mCurrentState.layersSortedByZ; 238325e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian const size_t count = currentLayers.size(); 238425e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian for (size_t i=0 ; i<count ; i++) { 238513127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer(currentLayers[i]); 238625e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian if (name.isEmpty() || (name == layer->getName())) { 238725e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian layer->clearStats(); 238825e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian } 238925e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian } 23904b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis 23914b0eba949cc026ffb2c75313042d8a7bcb3fcf86Jamie Gennis mAnimFrameTracker.clear(); 239225e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian} 239325e66fc324bbc004fa8902b2d4699e41bb601104Mathias Agopian 23946547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis// This should only be called from the main thread. Otherwise it would need 23956547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis// the lock and should use mCurrentState rather than mDrawingState. 23966547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennisvoid SurfaceFlinger::logFrameStats() { 23976547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis const LayerVector& drawingLayers = mDrawingState.layersSortedByZ; 23986547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis const size_t count = drawingLayers.size(); 23996547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis for (size_t i=0 ; i<count ; i++) { 24006547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis const sp<Layer>& layer(drawingLayers[i]); 24016547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis layer->logFrameStats(); 24026547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis } 24036547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis 24046547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis mAnimFrameTracker.logAndResetStats(String8("<win-anim>")); 24056547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis} 24066547ff4327aa320fbc9635668d3fc66db7dd78f6Jamie Gennis 24074803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden/*static*/ void SurfaceFlinger::appendSfConfigString(String8& result) 24084803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden{ 24094803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden static const char* config = 24104803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden " [sf" 24114803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden#ifdef NO_RGBX_8888 24124803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden " NO_RGBX_8888" 24134803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden#endif 24144803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden#ifdef HAS_CONTEXT_PRIORITY 24154803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden " HAS_CONTEXT_PRIORITY" 24164803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden#endif 24174803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden#ifdef NEVER_DEFAULT_TO_ASYNC_MODE 24184803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden " NEVER_DEFAULT_TO_ASYNC_MODE" 24194803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden#endif 24204803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden#ifdef TARGET_DISABLE_TRIPLE_BUFFERING 24214803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden " TARGET_DISABLE_TRIPLE_BUFFERING" 24224803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden#endif 24234803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden "]"; 24244803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden result.append(config); 24254803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden} 24264803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden 242774d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopianvoid SurfaceFlinger::dumpAllLocked(const Vector<String16>& args, size_t& index, 242874d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian String8& result) const 242982d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian{ 24303e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian bool colorize = false; 24313e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian if (index < args.size() 24323e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian && (args[index] == String16("--color"))) { 24333e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorize = true; 24343e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian index++; 24353e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian } 24363e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian 24373e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian Colorizer colorizer(colorize); 24383e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian 243982d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian // figure out if we're stuck somewhere 244082d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian const nsecs_t now = systemTime(); 244182d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian const nsecs_t inSwapBuffers(mDebugInSwapBuffers); 244282d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian const nsecs_t inTransaction(mDebugInTransaction); 244382d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian nsecs_t inSwapBuffersDuration = (inSwapBuffers) ? now-inSwapBuffers : 0; 244482d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0; 2445bc2d79ed7ada6243f3690f94ab512c0ddcdbed12Mathias Agopian 244682d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian /* 24474803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden * Dump library configuration. 24484803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden */ 24493e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian 24503e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.bold(result); 24514803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden result.append("Build configuration:"); 24523e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.reset(result); 24534803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden appendSfConfigString(result); 24544803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden appendUiConfigString(result); 24554803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden appendGuiConfigString(result); 24564803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden result.append("\n"); 24574803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden 24583e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.bold(result); 2459ca08833d5ea99130797e10ad68a651b50e99da74Mathias Agopian result.append("Sync configuration: "); 24603e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.reset(result); 2461ca08833d5ea99130797e10ad68a651b50e99da74Mathias Agopian result.append(SyncFeatures::getInstance().toString()); 2462ca08833d5ea99130797e10ad68a651b50e99da74Mathias Agopian result.append("\n"); 2463ca08833d5ea99130797e10ad68a651b50e99da74Mathias Agopian 24644803b74e2a12a508f7bbfde6f6a962fe3299c61cAndy McFadden /* 246582d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian * Dump the visible layer list 246682d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian */ 246782d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian const LayerVector& currentLayers = mCurrentState.layersSortedByZ; 246882d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian const size_t count = currentLayers.size(); 24693e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.bold(result); 247074d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian result.appendFormat("Visible layers (count = %d)\n", count); 24713e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.reset(result); 247282d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian for (size_t i=0 ; i<count ; i++) { 247313127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& layer(currentLayers[i]); 24743e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian layer->dump(result, colorizer); 247582d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian } 2476bc2d79ed7ada6243f3690f94ab512c0ddcdbed12Mathias Agopian 247782d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian /* 24785f20e2d4462da3471f59152b32cd8640fa4a21daMathias Agopian * Dump Display state 24795f20e2d4462da3471f59152b32cd8640fa4a21daMathias Agopian */ 24805f20e2d4462da3471f59152b32cd8640fa4a21daMathias Agopian 24813e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.bold(result); 248274d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian result.appendFormat("Displays (%d entries)\n", mDisplays.size()); 24833e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.reset(result); 24845f20e2d4462da3471f59152b32cd8640fa4a21daMathias Agopian for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { 24855f20e2d4462da3471f59152b32cd8640fa4a21daMathias Agopian const sp<const DisplayDevice>& hw(mDisplays[dpy]); 248674d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian hw->dump(result); 24875f20e2d4462da3471f59152b32cd8640fa4a21daMathias Agopian } 24885f20e2d4462da3471f59152b32cd8640fa4a21daMathias Agopian 24895f20e2d4462da3471f59152b32cd8640fa4a21daMathias Agopian /* 249082d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian * Dump SurfaceFlinger global state 249182d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian */ 24921b5e1021b8c9b87113b70d94dfb7b50f8c5b01b8Mathias Agopian 24933e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.bold(result); 249474d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian result.append("SurfaceFlinger global state:\n"); 24953e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.reset(result); 24961b5e1021b8c9b87113b70d94dfb7b50f8c5b01b8Mathias Agopian 2497888c822c4cb6976aab9256c58bae9e17e3e55c5cMathias Agopian HWComposer& hwc(getHwComposer()); 24984297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian sp<const DisplayDevice> hw(getDefaultDisplayDevice()); 2499ca08833d5ea99130797e10ad68a651b50e99da74Mathias Agopian 25003e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.bold(result); 25013e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian result.appendFormat("EGL implementation : %s\n", 25023e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian eglQueryStringImplementationANDROID(mEGLDisplay, EGL_VERSION)); 25033e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.reset(result); 25043e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian result.appendFormat("%s\n", 2505ca08833d5ea99130797e10ad68a651b50e99da74Mathias Agopian eglQueryStringImplementationANDROID(mEGLDisplay, EGL_EXTENSIONS)); 2506ca08833d5ea99130797e10ad68a651b50e99da74Mathias Agopian 2507875d8e1323536e16dcfc90c9674d7ad32116a69aMathias Agopian mRenderEngine->dump(result); 25089795c42e557cfa37b9fd353ef7a2a7977a77f504Mathias Agopian 25094297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian hw->undefinedRegion.dump(result, "undefinedRegion"); 251074d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian result.appendFormat(" orientation=%d, canDraw=%d\n", 25114297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian hw->getOrientation(), hw->canDraw()); 251274d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian result.appendFormat( 251382d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian " last eglSwapBuffers() time: %f us\n" 251482d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian " last transaction time : %f us\n" 2515c95dbdc236acf002b5f8aed8c8a9e43047fc75b5Mathias Agopian " transaction-flags : %08x\n" 251682d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian " refresh-rate : %f fps\n" 251782d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian " x-dpi : %f\n" 2518ed985574148a938bc3af24442eead313cc62521cMathias Agopian " y-dpi : %f\n" 2519ed985574148a938bc3af24442eead313cc62521cMathias Agopian " EGL_NATIVE_VISUAL_ID : %d\n" 2520ed985574148a938bc3af24442eead313cc62521cMathias Agopian " gpu_to_cpu_unsupported : %d\n" 2521ed985574148a938bc3af24442eead313cc62521cMathias Agopian , 252282d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian mLastSwapBufferTime/1000.0, 252382d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian mLastTransactionTime/1000.0, 2524c95dbdc236acf002b5f8aed8c8a9e43047fc75b5Mathias Agopian mTransactionFlags, 2525b0d1dd36f104c0b581674adc7f830cbf44b7db06Andy McFadden 1e9 / hwc.getRefreshPeriod(HWC_DISPLAY_PRIMARY), 2526b0d1dd36f104c0b581674adc7f830cbf44b7db06Andy McFadden hwc.getDpiX(HWC_DISPLAY_PRIMARY), 2527ed985574148a938bc3af24442eead313cc62521cMathias Agopian hwc.getDpiY(HWC_DISPLAY_PRIMARY), 2528ed985574148a938bc3af24442eead313cc62521cMathias Agopian mEGLNativeVisualId, 2529ed985574148a938bc3af24442eead313cc62521cMathias Agopian !mGpuToCpuSupported); 253082d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian 253174d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian result.appendFormat(" eglSwapBuffers time: %f us\n", 253282d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian inSwapBuffersDuration/1000.0); 253382d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian 253474d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian result.appendFormat(" transaction time: %f us\n", 253582d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian inTransactionDuration/1000.0); 253682d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian 253782d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian /* 253882d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian * VSYNC state 253982d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian */ 254074d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian mEventThread->dump(result); 254182d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian 254282d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian /* 254382d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian * Dump HWComposer state 254482d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian */ 25453e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.bold(result); 254674d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian result.append("h/w composer state:\n"); 25473e25fd8609b100a75721be82d1d499f0ae9083cbMathias Agopian colorizer.reset(result); 254874d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian result.appendFormat(" h/w composer %s and %s\n", 254982d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian hwc.initCheck()==NO_ERROR ? "present" : "not present", 2550ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian (mDebugDisableHWC || mDebugRegion || mDaltonize) ? "disabled" : "enabled"); 255174d211ae26a0257c6075a823812e40b55aa1e653Mathias Agopian hwc.dump(result); 255282d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian 255382d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian /* 255482d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian * Dump gralloc state 255582d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian */ 255682d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get()); 255782d7ab6c7e0cf971e515134ccf072682dd1a2cdbMathias Agopian alloc.dump(result); 2558edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 2559edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 256013127d8921356dff794250e04208c3ed60b3a3dfMathias Agopianconst Vector< sp<Layer> >& 256148bc05b56df9919fc39c5f2e3ea6535560eec98fJesse HallSurfaceFlinger::getLayerSortedByZForHwcDisplay(int id) { 2562db9b41fd157279d1b988a854e0d7c5b43c2fac38Mathias Agopian // Note: mStateLock is held here 256348bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall wp<IBinder> dpy; 256448bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall for (size_t i=0 ; i<mDisplays.size() ; i++) { 256548bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall if (mDisplays.valueAt(i)->getHwcDisplayId() == id) { 256648bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall dpy = mDisplays.keyAt(i); 256748bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall break; 256848bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall } 256948bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall } 257048bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall if (dpy == NULL) { 257148bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall ALOGE("getLayerSortedByZForHwcDisplay: invalid hwc display id %d", id); 257248bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall // Just use the primary display so we have something to return 257348bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall dpy = getBuiltInDisplay(DisplayDevice::DISPLAY_PRIMARY); 257448bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall } 257548bc05b56df9919fc39c5f2e3ea6535560eec98fJesse Hall return getDisplayDevice(dpy)->getVisibleLayersSortedByZ(); 2576cb55857bbde34a06c19dde3db5064d1717a0173eMathias Agopian} 2577cb55857bbde34a06c19dde3db5064d1717a0173eMathias Agopian 257863f165fd6b86d04be94d4023e845e98560504a96Keun young Parkbool SurfaceFlinger::startDdmConnection() 257963f165fd6b86d04be94d4023e845e98560504a96Keun young Park{ 258063f165fd6b86d04be94d4023e845e98560504a96Keun young Park void* libddmconnection_dso = 258163f165fd6b86d04be94d4023e845e98560504a96Keun young Park dlopen("libsurfaceflinger_ddmconnection.so", RTLD_NOW); 258263f165fd6b86d04be94d4023e845e98560504a96Keun young Park if (!libddmconnection_dso) { 258363f165fd6b86d04be94d4023e845e98560504a96Keun young Park return false; 258463f165fd6b86d04be94d4023e845e98560504a96Keun young Park } 258563f165fd6b86d04be94d4023e845e98560504a96Keun young Park void (*DdmConnection_start)(const char* name); 258663f165fd6b86d04be94d4023e845e98560504a96Keun young Park DdmConnection_start = 258763f165fd6b86d04be94d4023e845e98560504a96Keun young Park (typeof DdmConnection_start)dlsym(libddmconnection_dso, "DdmConnection_start"); 258863f165fd6b86d04be94d4023e845e98560504a96Keun young Park if (!DdmConnection_start) { 258963f165fd6b86d04be94d4023e845e98560504a96Keun young Park dlclose(libddmconnection_dso); 259063f165fd6b86d04be94d4023e845e98560504a96Keun young Park return false; 259163f165fd6b86d04be94d4023e845e98560504a96Keun young Park } 259263f165fd6b86d04be94d4023e845e98560504a96Keun young Park (*DdmConnection_start)(getServiceName()); 259363f165fd6b86d04be94d4023e845e98560504a96Keun young Park return true; 259463f165fd6b86d04be94d4023e845e98560504a96Keun young Park} 259563f165fd6b86d04be94d4023e845e98560504a96Keun young Park 2596edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Projectstatus_t SurfaceFlinger::onTransact( 2597edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 2598edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 2599edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project switch (code) { 2600edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project case CREATE_CONNECTION: 2601041a075262ef5fc886e46fd4eec3dd79ee2e60c0Mathias Agopian case CREATE_DISPLAY: 2602698c0873cf2e07bdc7fd1e72169aee2a19fa40d7Mathias Agopian case SET_TRANSACTION_STATE: 2603edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project case BOOT_FINISHED: 26048e533069e5721e55cb9768e140e16546c3a4a8b6Colin Cross case BLANK: 26058e533069e5721e55cb9768e140e16546c3a4a8b6Colin Cross case UNBLANK: 2606edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project { 2607edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project // codes that require permission check 2608edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project IPCThreadState* ipc = IPCThreadState::self(); 2609edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project const int pid = ipc->getCallingPid(); 2610a1ecca920e15ce04fe56ebf4f1b52ba711f9eb2dMathias Agopian const int uid = ipc->getCallingUid(); 261199b49840d309727678b77403d6cc9f920111623fMathias Agopian if ((uid != AID_GRAPHICS) && 261299b49840d309727678b77403d6cc9f920111623fMathias Agopian !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)) { 2613e6f43ddce78d6846af12550ff9193c5c6fe5844bSteve Block ALOGE("Permission Denial: " 2614375f56363a8737119ce2222dcfaacbe1cf733fc0Mathias Agopian "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid); 2615375f56363a8737119ce2222dcfaacbe1cf733fc0Mathias Agopian return PERMISSION_DENIED; 2616edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 26171b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian break; 26181b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian } 26191b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian case CAPTURE_SCREEN: 26201b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian { 26211b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian // codes that require permission check 26221b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian IPCThreadState* ipc = IPCThreadState::self(); 26231b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian const int pid = ipc->getCallingPid(); 26241b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian const int uid = ipc->getCallingUid(); 262599b49840d309727678b77403d6cc9f920111623fMathias Agopian if ((uid != AID_GRAPHICS) && 262699b49840d309727678b77403d6cc9f920111623fMathias Agopian !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) { 2627e6f43ddce78d6846af12550ff9193c5c6fe5844bSteve Block ALOGE("Permission Denial: " 26281b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian "can't read framebuffer pid=%d, uid=%d", pid, uid); 26291b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian return PERMISSION_DENIED; 26301b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian } 26311b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian break; 2632edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 2633edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 26341b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian 2635edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags); 2636edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) { 2637b8a5560e1303cb10f5cd482af466fc04d2bdfcabMathias Agopian CHECK_INTERFACE(ISurfaceComposer, data, reply); 263899ed22412db547c59d3da08114d9d5a586442b30Glenn Kasten if (CC_UNLIKELY(!PermissionCache::checkCallingPermission(sHardwareTest))) { 2639375f56363a8737119ce2222dcfaacbe1cf733fc0Mathias Agopian IPCThreadState* ipc = IPCThreadState::self(); 2640375f56363a8737119ce2222dcfaacbe1cf733fc0Mathias Agopian const int pid = ipc->getCallingPid(); 2641375f56363a8737119ce2222dcfaacbe1cf733fc0Mathias Agopian const int uid = ipc->getCallingUid(); 2642e6f43ddce78d6846af12550ff9193c5c6fe5844bSteve Block ALOGE("Permission Denial: " 2643375f56363a8737119ce2222dcfaacbe1cf733fc0Mathias Agopian "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid); 2644edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project return PERMISSION_DENIED; 2645edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 2646edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project int n; 2647edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project switch (code) { 264801b766839e06c32540cef100e3a7710d12cf1eefMathias Agopian case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE 264935b48d10bc9e064201d3d54d2d476314684a7a05Mathias Agopian case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE 2650edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project return NO_ERROR; 2651edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project case 1002: // SHOW_UPDATES 2652edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project n = data.readInt32(); 2653edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project mDebugRegion = n ? n : (mDebugRegion ? 0 : 1); 265453331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian invalidateHwcGeometry(); 265553331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian repaintEverything(); 2656edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project return NO_ERROR; 2657edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project case 1004:{ // repaint everything 265853331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian repaintEverything(); 2659cbb288bfe89f585bf48371bd31b2d4aafa32f32eMathias Agopian return NO_ERROR; 2660cbb288bfe89f585bf48371bd31b2d4aafa32f32eMathias Agopian } 2661cbb288bfe89f585bf48371bd31b2d4aafa32f32eMathias Agopian case 1005:{ // force transaction 2662e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian setTransactionFlags( 2663e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian eTransactionNeeded| 2664e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian eDisplayTransactionNeeded| 2665e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian eTraversalNeeded); 2666cbb288bfe89f585bf48371bd31b2d4aafa32f32eMathias Agopian return NO_ERROR; 2667edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 26684d143eed994778d37eb09bb5d452c26f12bca6e1Mathias Agopian case 1006:{ // send empty update 26694d143eed994778d37eb09bb5d452c26f12bca6e1Mathias Agopian signalRefresh(); 26704d143eed994778d37eb09bb5d452c26f12bca6e1Mathias Agopian return NO_ERROR; 26714d143eed994778d37eb09bb5d452c26f12bca6e1Mathias Agopian } 267253331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian case 1008: // toggle use of hw composer 267353331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian n = data.readInt32(); 267453331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian mDebugDisableHWC = n ? 1 : 0; 267553331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian invalidateHwcGeometry(); 267653331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian repaintEverything(); 267753331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian return NO_ERROR; 2678a45836466c301d49d8df286b5317dfa99cb83b70Mathias Agopian case 1009: // toggle use of transform hint 2679a45836466c301d49d8df286b5317dfa99cb83b70Mathias Agopian n = data.readInt32(); 2680a45836466c301d49d8df286b5317dfa99cb83b70Mathias Agopian mDebugDisableTransformHint = n ? 1 : 0; 2681a45836466c301d49d8df286b5317dfa99cb83b70Mathias Agopian invalidateHwcGeometry(); 2682a45836466c301d49d8df286b5317dfa99cb83b70Mathias Agopian repaintEverything(); 2683a45836466c301d49d8df286b5317dfa99cb83b70Mathias Agopian return NO_ERROR; 2684edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project case 1010: // interrogate. 268501b766839e06c32540cef100e3a7710d12cf1eefMathias Agopian reply->writeInt32(0); 2686edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project reply->writeInt32(0); 2687edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project reply->writeInt32(mDebugRegion); 2688b9494d5c9d44e4a59b6d510fea1665de434f3c6bMathias Agopian reply->writeInt32(0); 268912839bee29bdcc65731b4d42029cc59e2320c5c4Dianne Hackborn reply->writeInt32(mDebugDisableHWC); 2690edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project return NO_ERROR; 2691edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project case 1013: { 2692edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project Mutex::Autolock _l(mStateLock); 26934297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian sp<const DisplayDevice> hw(getDefaultDisplayDevice()); 26944297734c1156fd8ede7e9c61b1e439f9e1c18cd9Mathias Agopian reply->writeInt32(hw->getPageFlipCount()); 2695ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian return NO_ERROR; 2696ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian } 2697ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian case 1014: { 2698ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian // daltonize 2699ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian n = data.readInt32(); 2700ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian switch (n % 10) { 2701ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian case 1: mDaltonizer.setType(Daltonizer::protanomaly); break; 2702ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian case 2: mDaltonizer.setType(Daltonizer::deuteranomaly); break; 2703ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian case 3: mDaltonizer.setType(Daltonizer::tritanomaly); break; 2704ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian } 2705ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian if (n >= 10) { 2706ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian mDaltonizer.setMode(Daltonizer::correction); 2707ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian } else { 2708ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian mDaltonizer.setMode(Daltonizer::simulation); 2709ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian } 2710ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian mDaltonize = n > 0; 2711ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian invalidateHwcGeometry(); 2712ff2ed70fa30f04b90dd1a2c06ec2319e157152d7Mathias Agopian repaintEverything(); 2713edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 2714edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project return NO_ERROR; 2715edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 2716edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project } 2717edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project return err; 2718edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project} 2719edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project 272053331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopianvoid SurfaceFlinger::repaintEverything() { 272187baae104a3e4c2059990b01c393476065c558b0Mathias Agopian android_atomic_or(1, &mRepaintEverything); 272299ce5cdeb383216dee95af4d90e47406b0948ea1Mathias Agopian signalTransaction(); 272353331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian} 272453331da007b56e0cb4201728de99c8c29bcfaa9aMathias Agopian 272559119e658a12279e8fff508f8773843de2d90917Mathias Agopian// --------------------------------------------------------------------------- 27262a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian// Capture screen into an IGraphiBufferProducer 27272a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian// --------------------------------------------------------------------------- 272859119e658a12279e8fff508f8773843de2d90917Mathias Agopian 27292ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian/* The code below is here to handle b/8734824 27302ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian * 27312ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian * We create a IGraphicBufferProducer wrapper that forwards all calls 27322ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian * to the calling binder thread, where they are executed. This allows 27332ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian * the calling thread to be reused (on the other side) and not 27342ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian * depend on having "enough" binder threads to handle the requests. 27352ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian * 27362ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian */ 27372ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian 27382ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopianclass GraphicProducerWrapper : public BBinder, public MessageHandler { 27392ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian sp<IGraphicBufferProducer> impl; 27402ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian sp<Looper> looper; 27412ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian status_t result; 27422ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian bool exitPending; 27432ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian bool exitRequested; 27442ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian mutable Barrier barrier; 27452ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian volatile int32_t memoryBarrier; 27462ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian uint32_t code; 27472ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian Parcel const* data; 27482ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian Parcel* reply; 27492ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian 27502ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian enum { 27512ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian MSG_API_CALL, 27522ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian MSG_EXIT 27532ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian }; 27542ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian 27552ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian /* 27562ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian * this is called by our "fake" BpGraphicBufferProducer. We package the 27572ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian * data and reply Parcel and forward them to the calling thread. 27582ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian */ 27592ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian virtual status_t transact(uint32_t code, 27602ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian const Parcel& data, Parcel* reply, uint32_t flags) { 27612ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian this->code = code; 27622ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian this->data = &data; 27632ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian this->reply = reply; 27642ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian android_atomic_acquire_store(0, &memoryBarrier); 27652ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian if (exitPending) { 27662ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian // if we've exited, we run the message synchronously right here 27672ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian handleMessage(Message(MSG_API_CALL)); 27682ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian } else { 27692ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian barrier.close(); 27702ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian looper->sendMessage(this, Message(MSG_API_CALL)); 27712ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian barrier.wait(); 27722ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian } 27732ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian return NO_ERROR; 27742ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian } 27752ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian 27762ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian /* 27772ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian * here we run on the binder calling thread. All we've got to do is 27782ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian * call the real BpGraphicBufferProducer. 27792ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian */ 27802ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian virtual void handleMessage(const Message& message) { 27812ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian android_atomic_release_load(&memoryBarrier); 27822ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian if (message.what == MSG_API_CALL) { 27832ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian impl->asBinder()->transact(code, data[0], reply); 27842ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian barrier.open(); 27852ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian } else if (message.what == MSG_EXIT) { 27862ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian exitRequested = true; 27872ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian } 27882ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian } 27892ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian 27902ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopianpublic: 27912ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian GraphicProducerWrapper(const sp<IGraphicBufferProducer>& impl) : 27922ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian impl(impl), looper(new Looper(true)), result(NO_ERROR), 27932ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian exitPending(false), exitRequested(false) { 27942ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian } 27952ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian 27962ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian status_t waitForResponse() { 27972ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian do { 27982ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian looper->pollOnce(-1); 27992ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian } while (!exitRequested); 28002ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian return result; 28012ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian } 28022ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian 28032ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian void exit(status_t result) { 2804aaff4ef717c08f6aed7ccd96e1d65222ceb4fd17Mike J. Chen this->result = result; 28052ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian exitPending = true; 28062ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian looper->sendMessage(this, Message(MSG_EXIT)); 28072ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian } 28082ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian}; 28092ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian 28102ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian 28112a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopianstatus_t SurfaceFlinger::captureScreen(const sp<IBinder>& display, 28122a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian const sp<IGraphicBufferProducer>& producer, 28132a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian uint32_t reqWidth, uint32_t reqHeight, 28143ca76f416bc8665a97636ca8a2d0128b9da9d92cMathias Agopian uint32_t minLayerZ, uint32_t maxLayerZ) { 28152a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian 28162a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian if (CC_UNLIKELY(display == 0)) 28172a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian return BAD_VALUE; 28182a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian 28192a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian if (CC_UNLIKELY(producer == 0)) 28202a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian return BAD_VALUE; 28212a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian 28225ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian // if we have secure windows on this display, never allow the screen capture 28235ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian // unless the producer interface is local (i.e.: we can take a screenshot for 28245ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian // ourselves). 28255ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian if (!producer->asBinder()->localBinder()) { 28265ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian Mutex::Autolock _l(mStateLock); 28275ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian sp<const DisplayDevice> hw(getDisplayDevice(display)); 28285ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian if (hw->getSecureLayerVisible()) { 28295ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian ALOGW("FB is protected: PERMISSION_DENIED"); 28305ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian return PERMISSION_DENIED; 28315ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian } 28325ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian } 28335ff5a84e4829bad9eb44cc9a32d8579ca089051bMathias Agopian 28342a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian class MessageCaptureScreen : public MessageBase { 28352a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian SurfaceFlinger* flinger; 28362a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian sp<IBinder> display; 28372a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian sp<IGraphicBufferProducer> producer; 28382a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian uint32_t reqWidth, reqHeight; 28392a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian uint32_t minLayerZ,maxLayerZ; 28402a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian status_t result; 28412a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian public: 28422a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian MessageCaptureScreen(SurfaceFlinger* flinger, 28432a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian const sp<IBinder>& display, 28442a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian const sp<IGraphicBufferProducer>& producer, 28452a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian uint32_t reqWidth, uint32_t reqHeight, 28463ca76f416bc8665a97636ca8a2d0128b9da9d92cMathias Agopian uint32_t minLayerZ, uint32_t maxLayerZ) 28472a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian : flinger(flinger), display(display), producer(producer), 28482a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian reqWidth(reqWidth), reqHeight(reqHeight), 28492a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian minLayerZ(minLayerZ), maxLayerZ(maxLayerZ), 28502a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian result(PERMISSION_DENIED) 28512a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian { 28522a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian } 28532a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian status_t getResult() const { 28542a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian return result; 28552a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian } 28562a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian virtual bool handler() { 28572a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian Mutex::Autolock _l(flinger->mStateLock); 28582a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian sp<const DisplayDevice> hw(flinger->getDisplayDevice(display)); 28590aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian result = flinger->captureScreenImplLocked(hw, 28603ca76f416bc8665a97636ca8a2d0128b9da9d92cMathias Agopian producer, reqWidth, reqHeight, minLayerZ, maxLayerZ); 28612ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian static_cast<GraphicProducerWrapper*>(producer->asBinder().get())->exit(result); 28622a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian return true; 28632a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian } 28642a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian }; 28652a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian 28669eb1f0558b5fc78920602afe7bcfa3115bb1f6beMathias Agopian // make sure to process transactions before screenshots -- a transaction 28679eb1f0558b5fc78920602afe7bcfa3115bb1f6beMathias Agopian // might already be pending but scheduled for VSYNC; this guarantees we 28689eb1f0558b5fc78920602afe7bcfa3115bb1f6beMathias Agopian // will handle it before the screenshot. When VSYNC finally arrives 28699eb1f0558b5fc78920602afe7bcfa3115bb1f6beMathias Agopian // the scheduled transaction will be a no-op. If no transactions are 28709eb1f0558b5fc78920602afe7bcfa3115bb1f6beMathias Agopian // scheduled at this time, this will end-up being a no-op as well. 28719eb1f0558b5fc78920602afe7bcfa3115bb1f6beMathias Agopian mEventQueue.invalidateTransactionNow(); 28729eb1f0558b5fc78920602afe7bcfa3115bb1f6beMathias Agopian 28732ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian // this creates a "fake" BBinder which will serve as a "fake" remote 28742ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian // binder to receive the marshaled calls and forward them to the 28752ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian // real remote (a BpGraphicBufferProducer) 28762ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian sp<GraphicProducerWrapper> wrapper = new GraphicProducerWrapper(producer); 28772ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian 28782ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian // the asInterface() call below creates our "fake" BpGraphicBufferProducer 28792ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian // which does the marshaling work forwards to our "fake remote" above. 28802a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian sp<MessageBase> msg = new MessageCaptureScreen(this, 28812ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian display, IGraphicBufferProducer::asInterface( wrapper ), 28823ca76f416bc8665a97636ca8a2d0128b9da9d92cMathias Agopian reqWidth, reqHeight, minLayerZ, maxLayerZ); 28832ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian 28842ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian status_t res = postMessageAsync(msg); 28852a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian if (res == NO_ERROR) { 28862ed0fe59b482f8d6b35a50ebc8e9e060813f4568Mathias Agopian res = wrapper->waitForResponse(); 28872a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian } 28882a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian return res; 2889118d0245ee0a3b107055782aa8b555404b6f0280Mathias Agopian} 2890118d0245ee0a3b107055782aa8b555404b6f0280Mathias Agopian 2891180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 2892180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopianvoid SurfaceFlinger::renderScreenImplLocked( 2893180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian const sp<const DisplayDevice>& hw, 2894180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian uint32_t reqWidth, uint32_t reqHeight, 2895180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian uint32_t minLayerZ, uint32_t maxLayerZ, 2896180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian bool yswap) 2897180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian{ 2898180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian ATRACE_CALL(); 28993f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian RenderEngine& engine(getRenderEngine()); 2900180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 2901180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian // get screen geometry 2902180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian const uint32_t hw_w = hw->getWidth(); 2903180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian const uint32_t hw_h = hw->getHeight(); 2904180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian const bool filtering = reqWidth != hw_w || reqWidth != hw_h; 2905180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 2906180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian // make sure to clear all GL error flags 29073f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian engine.checkErrors(); 2908180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 2909180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian // set-up our viewport 29103f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian engine.setViewportAndProjection(reqWidth, reqHeight, hw_w, hw_h, yswap); 29113f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian engine.disableTexturing(); 2912180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 2913180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian // redraw the screen entirely... 29143f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian engine.clearWithColor(0, 0, 0, 1); 2915180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 2916180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian const LayerVector& layers( mDrawingState.layersSortedByZ ); 2917180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian const size_t count = layers.size(); 2918180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian for (size_t i=0 ; i<count ; ++i) { 2919180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian const sp<Layer>& layer(layers[i]); 29201eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian const Layer::State& state(layer->getDrawingState()); 2921180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian if (state.layerStack == hw->getLayerStack()) { 2922180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian if (state.z >= minLayerZ && state.z <= maxLayerZ) { 2923180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian if (layer->isVisible()) { 2924180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian if (filtering) layer->setFiltering(true); 2925180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian layer->draw(hw); 2926180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian if (filtering) layer->setFiltering(false); 2927180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian } 2928180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian } 2929180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian } 2930180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian } 2931180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 2932180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian // compositionComplete is needed for older driver 2933180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian hw->compositionComplete(); 2934931bda1c472ba8c8e965bdba6757ff94154df903Mathias Agopian hw->setViewportAndProjection(); 2935180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian} 2936180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 2937180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 29382a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopianstatus_t SurfaceFlinger::captureScreenImplLocked( 29392a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian const sp<const DisplayDevice>& hw, 29402a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian const sp<IGraphicBufferProducer>& producer, 29412a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian uint32_t reqWidth, uint32_t reqHeight, 29423ca76f416bc8665a97636ca8a2d0128b9da9d92cMathias Agopian uint32_t minLayerZ, uint32_t maxLayerZ) 294374c40c0a273dbfd7d10617c4cc1b0c066bfc812eMathias Agopian{ 2944fddc28d87136b55f0d9613e5f8ecd64a6aca018dMathias Agopian ATRACE_CALL(); 2945fddc28d87136b55f0d9613e5f8ecd64a6aca018dMathias Agopian 2946180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian // get screen geometry 2947180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian const uint32_t hw_w = hw->getWidth(); 2948180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian const uint32_t hw_h = hw->getHeight(); 2949180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 2950180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian if ((reqWidth > hw_w) || (reqHeight > hw_h)) { 2951180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian ALOGE("size mismatch (%d, %d) > (%d, %d)", 2952180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian reqWidth, reqHeight, hw_w, hw_h); 2953180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian return BAD_VALUE; 2954180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian } 2955180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 2956180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian reqWidth = (!reqWidth) ? hw_w : reqWidth; 2957180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian reqHeight = (!reqHeight) ? hw_h : reqHeight; 2958180f10de6f504d2ba56ff32ae8ed53c58bb458e9Mathias Agopian 29590aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian // create a surface (because we're a producer, and we need to 29600aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian // dequeue/queue a buffer) 296183cafffeac037ab2f9d00f98f8d2f3da8fc9b857Jesse Hall sp<Surface> sur = new Surface(producer, false); 29620aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian ANativeWindow* window = sur.get(); 296374c40c0a273dbfd7d10617c4cc1b0c066bfc812eMathias Agopian 29640aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian status_t result = NO_ERROR; 29650aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian if (native_window_api_connect(window, NATIVE_WINDOW_API_EGL) == NO_ERROR) { 29663ca76f416bc8665a97636ca8a2d0128b9da9d92cMathias Agopian uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN | 29673ca76f416bc8665a97636ca8a2d0128b9da9d92cMathias Agopian GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE; 29682a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian 29690aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian int err = 0; 29700aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian err = native_window_set_buffers_dimensions(window, reqWidth, reqHeight); 29714ceff3d5efd27c164788bb2b3f0fd17c691a0204Mathias Agopian err |= native_window_set_scaling_mode(window, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW); 29720aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian err |= native_window_set_buffers_format(window, HAL_PIXEL_FORMAT_RGBA_8888); 29730aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian err |= native_window_set_usage(window, usage); 29742a9fc493dfdba67108e4335bb1fe931bc1e2a025Mathias Agopian 29750aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian if (err == NO_ERROR) { 29760aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian ANativeWindowBuffer* buffer; 29770aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian /* TODO: Once we have the sync framework everywhere this can use 29780aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian * server-side waits on the fence that dequeueBuffer returns. 29790aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian */ 29800aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian result = native_window_dequeue_buffer_and_wait(window, &buffer); 29810aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian if (result == NO_ERROR) { 29820aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian // create an EGLImage from the buffer so we can later 29830aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian // turn it into a texture 29840aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian EGLImageKHR image = eglCreateImageKHR(mEGLDisplay, EGL_NO_CONTEXT, 29850aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian EGL_NATIVE_BUFFER_ANDROID, buffer, NULL); 29860aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian if (image != EGL_NO_IMAGE_KHR) { 29873f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian // this binds the given EGLImage as a framebuffer for the 29883f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian // duration of this scope. 29893f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian RenderEngine::BindImageAsFramebuffer imageBond(getRenderEngine(), image); 29903f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian if (imageBond.getStatus() == NO_ERROR) { 29910aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian // this will in fact render into our dequeued buffer 29920aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian // via an FBO, which means we didn't have to create 29930aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian // an EGLSurface and therefore we're not 29940aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian // dependent on the context's EGLConfig. 29950aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian renderScreenImplLocked(hw, reqWidth, reqHeight, 29960aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian minLayerZ, maxLayerZ, true); 2997d555684cb36dfb959694db76962e570184f98838Mathias Agopian 29982d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden // Create a sync point and wait on it, so we know the buffer is 29992d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden // ready before we pass it along. We can't trivially call glFlush(), 30002d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden // so we use a wait flag instead. 30012d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden // TODO: pass a sync fd to queueBuffer() and let the consumer wait. 30022d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden EGLSyncKHR sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, NULL); 30032d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden if (sync != EGL_NO_SYNC_KHR) { 30042d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden EGLint result = eglClientWaitSyncKHR(mEGLDisplay, sync, 30052d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, 2000000000 /*2 sec*/); 30062d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden EGLint eglErr = eglGetError(); 30072d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden eglDestroySyncKHR(mEGLDisplay, sync); 30082d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden if (result == EGL_TIMEOUT_EXPIRED_KHR) { 30092d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden ALOGW("captureScreen: fence wait timed out"); 30102d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden } else { 30112d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden ALOGW_IF(eglErr != EGL_SUCCESS, 30122d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden "captureScreen: error waiting on EGL fence: %#x", eglErr); 30132d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden } 30142d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden } else { 30152d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden ALOGW("captureScreen: error creating EGL fence: %#x", eglGetError()); 30162d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden // not fatal 30172d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden } 30182d8d120dc175c131a75e93fb1de61a9f432ddce9Andy McFadden 3019d555684cb36dfb959694db76962e570184f98838Mathias Agopian if (DEBUG_SCREENSHOTS) { 3020d555684cb36dfb959694db76962e570184f98838Mathias Agopian uint32_t* pixels = new uint32_t[reqWidth*reqHeight]; 3021d555684cb36dfb959694db76962e570184f98838Mathias Agopian getRenderEngine().readPixels(0, 0, reqWidth, reqHeight, pixels); 3022d555684cb36dfb959694db76962e570184f98838Mathias Agopian checkScreenshot(reqWidth, reqHeight, reqWidth, pixels, 3023d555684cb36dfb959694db76962e570184f98838Mathias Agopian hw, minLayerZ, maxLayerZ); 3024d555684cb36dfb959694db76962e570184f98838Mathias Agopian delete [] pixels; 3025d555684cb36dfb959694db76962e570184f98838Mathias Agopian } 3026d555684cb36dfb959694db76962e570184f98838Mathias Agopian 30270aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian } else { 30280aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian ALOGE("got GL_FRAMEBUFFER_COMPLETE_OES error while taking screenshot"); 30290aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian result = INVALID_OPERATION; 30300aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian } 30310aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian // destroy our image 30320aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian eglDestroyImageKHR(mEGLDisplay, image); 30330aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian } else { 30340aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian result = BAD_VALUE; 303574c40c0a273dbfd7d10617c4cc1b0c066bfc812eMathias Agopian } 30360aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian window->queueBuffer(window, buffer, -1); 303774c40c0a273dbfd7d10617c4cc1b0c066bfc812eMathias Agopian } 30380aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian } else { 30390aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian result = BAD_VALUE; 304074c40c0a273dbfd7d10617c4cc1b0c066bfc812eMathias Agopian } 30410aea53ff3f71f9f8df55d1cf58fd586442582643Mathias Agopian native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL); 304274c40c0a273dbfd7d10617c4cc1b0c066bfc812eMathias Agopian } 304374c40c0a273dbfd7d10617c4cc1b0c066bfc812eMathias Agopian 304474c40c0a273dbfd7d10617c4cc1b0c066bfc812eMathias Agopian return result; 304574c40c0a273dbfd7d10617c4cc1b0c066bfc812eMathias Agopian} 304674c40c0a273dbfd7d10617c4cc1b0c066bfc812eMathias Agopian 3047d555684cb36dfb959694db76962e570184f98838Mathias Agopianvoid SurfaceFlinger::checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr, 3048d555684cb36dfb959694db76962e570184f98838Mathias Agopian const sp<const DisplayDevice>& hw, uint32_t minLayerZ, uint32_t maxLayerZ) { 3049fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian if (DEBUG_SCREENSHOTS) { 3050d555684cb36dfb959694db76962e570184f98838Mathias Agopian for (size_t y=0 ; y<h ; y++) { 3051d555684cb36dfb959694db76962e570184f98838Mathias Agopian uint32_t const * p = (uint32_t const *)vaddr + y*s; 3052d555684cb36dfb959694db76962e570184f98838Mathias Agopian for (size_t x=0 ; x<w ; x++) { 3053fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian if (p[x] != 0xFF000000) return; 3054fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian } 3055fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian } 3056fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian ALOGE("*** we just took a black screenshot ***\n" 3057fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian "requested minz=%d, maxz=%d, layerStack=%d", 3058fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian minLayerZ, maxLayerZ, hw->getLayerStack()); 3059fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian const LayerVector& layers( mDrawingState.layersSortedByZ ); 3060fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian const size_t count = layers.size(); 3061fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian for (size_t i=0 ; i<count ; ++i) { 3062fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian const sp<Layer>& layer(layers[i]); 3063fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian const Layer::State& state(layer->getDrawingState()); 3064fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian const bool visible = (state.layerStack == hw->getLayerStack()) 3065fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian && (state.z >= minLayerZ && state.z <= maxLayerZ) 3066fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian && (layer->isVisible()); 3067fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian ALOGE("%c index=%d, name=%s, layerStack=%d, z=%d, visible=%d, flags=%x, alpha=%x", 3068fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian visible ? '+' : '-', 3069fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian i, layer->getName().string(), state.layerStack, state.z, 3070fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian layer->isVisible(), state.flags, state.alpha); 3071fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian } 3072fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian } 3073fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian} 3074fee2b463c5fbe8fa0132d03634ccc02ea55c1505Mathias Agopian 30751b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian// --------------------------------------------------------------------------- 30761b0b30d04304392748a8a4ab5a69e52a19f51b3aMathias Agopian 3077921e6ac4b7610a178285898d191eb0e3afe906c0Mathias AgopianSurfaceFlinger::LayerVector::LayerVector() { 3078921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian} 3079921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian 3080921e6ac4b7610a178285898d191eb0e3afe906c0Mathias AgopianSurfaceFlinger::LayerVector::LayerVector(const LayerVector& rhs) 308113127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian : SortedVector<sp<Layer> >(rhs) { 3082921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian} 3083921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian 3084921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopianint SurfaceFlinger::LayerVector::do_compare(const void* lhs, 3085921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian const void* rhs) const 3086edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project{ 3087be246f86bd6378a5110e81e9d9068ab03c3b077eMathias Agopian // sort layers per layer-stack, then by z-order and finally by sequence 308813127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& l(*reinterpret_cast<const sp<Layer>*>(lhs)); 308913127d8921356dff794250e04208c3ed60b3a3dfMathias Agopian const sp<Layer>& r(*reinterpret_cast<const sp<Layer>*>(rhs)); 3090be246f86bd6378a5110e81e9d9068ab03c3b077eMathias Agopian 30911eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian uint32_t ls = l->getCurrentState().layerStack; 30921eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian uint32_t rs = r->getCurrentState().layerStack; 3093be246f86bd6378a5110e81e9d9068ab03c3b077eMathias Agopian if (ls != rs) 3094be246f86bd6378a5110e81e9d9068ab03c3b077eMathias Agopian return ls - rs; 3095be246f86bd6378a5110e81e9d9068ab03c3b077eMathias Agopian 30961eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian uint32_t lz = l->getCurrentState().z; 30971eae0ee49402c39f1b08cc8fec129023f86494b7Mathias Agopian uint32_t rz = r->getCurrentState().z; 3098be246f86bd6378a5110e81e9d9068ab03c3b077eMathias Agopian if (lz != rz) 3099be246f86bd6378a5110e81e9d9068ab03c3b077eMathias Agopian return lz - rz; 3100be246f86bd6378a5110e81e9d9068ab03c3b077eMathias Agopian 3101be246f86bd6378a5110e81e9d9068ab03c3b077eMathias Agopian return l->sequence - r->sequence; 3102921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian} 3103921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian 3104921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian// --------------------------------------------------------------------------- 3105921e6ac4b7610a178285898d191eb0e3afe906c0Mathias Agopian 31063ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias AgopianSurfaceFlinger::DisplayDeviceState::DisplayDeviceState() 31073ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias Agopian : type(DisplayDevice::DISPLAY_ID_INVALID) { 3108e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian} 3109e57f292595bec48f65c8088b00ff6beea01217e9Mathias Agopian 31103ee454a7bef8bd3d1c9cdd9d17108eb80ebadf2aMathias AgopianSurfaceFlinger::DisplayDeviceState::DisplayDeviceState(DisplayDevice::DisplayType type) 311101e29054e672301e4adbbca15b3562a59a20f267Jesse Hall : type(type), layerStack(DisplayDevice::NO_LAYER_STACK), orientation(0) { 3112da8d0a5c0cf9d41915d3b106cad4aaec3e767c11Mathias Agopian viewport.makeInvalid(); 3113da8d0a5c0cf9d41915d3b106cad4aaec3e767c11Mathias Agopian frame.makeInvalid(); 3114b7e930db175c192464cebdeb49eb56cf6dd60114Mathias Agopian} 31157303c6bf1a8b00a0e7d8165d774a1f259b4ccda9Mathias Agopian 3116b7e930db175c192464cebdeb49eb56cf6dd60114Mathias Agopian// --------------------------------------------------------------------------- 311796f0819f81293076e652792794a961543e6750d7Mathias Agopian 3118edbf3b6af777b721cd2a1ef461947e51e88241e1The Android Open Source Project}; // namespace android 31193f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian 31203f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian 31213f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian#if defined(__gl_h_) 31223f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian#error "don't include gl/gl.h in this file" 31233f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian#endif 31243f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian 31253f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian#if defined(__gl2_h_) 31263f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian#error "don't include gl2/gl2.h in this file" 31273f84483382be2d528918cc1a6fbc6a7d68e0b181Mathias Agopian#endif 3128