blob: 5c7cf0758c07a10931a15777c3a6a1138b66598e [file] [log] [blame]
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Jamie Gennis1c8e95c2012-02-23 19:27:23 -080017#define ATRACE_TAG ATRACE_TAG_GRAPHICS
18
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080019#include <stdint.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070020#include <sys/types.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080021#include <errno.h>
22#include <math.h>
Keun young Park63f165f2012-08-31 10:53:36 -070023#include <dlfcn.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070024
25#include <EGL/egl.h>
26#include <GLES/gl.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080027
28#include <cutils/log.h>
29#include <cutils/properties.h>
30
Mathias Agopianc5b2c0b2009-05-19 19:08:10 -070031#include <binder/IPCThreadState.h>
32#include <binder/IServiceManager.h>
Mathias Agopian7303c6b2009-07-02 18:11:53 -070033#include <binder/MemoryHeapBase.h>
Mathias Agopian99b49842011-06-27 16:05:52 -070034#include <binder/PermissionCache.h>
Mathias Agopian7303c6b2009-07-02 18:11:53 -070035
Mathias Agopianc666cae2012-07-25 18:56:13 -070036#include <ui/DisplayInfo.h>
37
Mathias Agopian921e6ac2012-07-23 23:11:29 -070038#include <gui/BitTube.h>
Jamie Gennis1a4d8832012-08-02 20:11:05 -070039#include <gui/BufferQueue.h>
Andy McFadden4803b742012-09-24 19:07:20 -070040#include <gui/GuiConfig.h>
Jamie Gennis1a4d8832012-08-02 20:11:05 -070041#include <gui/IDisplayEventConnection.h>
Mathias Agopiane3c697f2013-02-14 17:11:02 -080042#include <gui/Surface.h>
Jamie Gennis392edd82012-11-29 23:26:29 -080043#include <gui/GraphicBufferAlloc.h>
Mathias Agopian921e6ac2012-07-23 23:11:29 -070044
45#include <ui/GraphicBufferAllocator.h>
46#include <ui/PixelFormat.h>
Andy McFadden4803b742012-09-24 19:07:20 -070047#include <ui/UiConfig.h>
Mathias Agopiand0566bc2011-11-17 17:49:17 -080048
Mathias Agopiancde87a32012-09-13 14:09:01 -070049#include <utils/misc.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080050#include <utils/String8.h>
51#include <utils/String16.h>
52#include <utils/StopWatch.h>
Jamie Gennis1c8e95c2012-02-23 19:27:23 -080053#include <utils/Trace.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080054
Mathias Agopian921e6ac2012-07-23 23:11:29 -070055#include <private/android_filesystem_config.h>
Mathias Agopianca088332013-03-28 17:44:13 -070056#include <private/gui/SyncFeatures.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080057
58#include "clz.h"
Mathias Agopian90ac7992012-02-25 18:48:35 -080059#include "DdmConnection.h"
Mathias Agopian0f2f5ff2012-07-31 23:09:07 -070060#include "DisplayDevice.h"
Mathias Agopiandb403e82012-06-18 16:47:56 -070061#include "Client.h"
Mathias Agopiand0566bc2011-11-17 17:49:17 -080062#include "EventThread.h"
Mathias Agopian1f7bec62010-06-25 18:02:21 -070063#include "GLExtensions.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080064#include "Layer.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080065#include "LayerDim.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080066#include "SurfaceFlinger.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080067
Mathias Agopiana4912602012-07-12 14:25:33 -070068#include "DisplayHardware/FramebufferSurface.h"
Mathias Agopiana350ff92010-08-10 17:14:02 -070069#include "DisplayHardware/HWComposer.h"
Jesse Hall99c7dbb2013-03-14 14:29:29 -070070#include "DisplayHardware/VirtualDisplaySurface.h"
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080071
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080072#define DISPLAY_COUNT 1
73
Mathias Agopianca088332013-03-28 17:44:13 -070074EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name);
75
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080076namespace android {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080077// ---------------------------------------------------------------------------
78
Mathias Agopian99b49842011-06-27 16:05:52 -070079const String16 sHardwareTest("android.permission.HARDWARE_TEST");
80const String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER");
81const String16 sReadFramebuffer("android.permission.READ_FRAME_BUFFER");
82const String16 sDump("android.permission.DUMP");
83
84// ---------------------------------------------------------------------------
85
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080086SurfaceFlinger::SurfaceFlinger()
87 : BnSurfaceComposer(), Thread(false),
88 mTransactionFlags(0),
Jamie Gennis2d5e2302012-10-15 18:24:43 -070089 mTransactionPending(false),
90 mAnimTransactionPending(false),
Mathias Agopian076b1cc2009-04-10 14:24:30 -070091 mLayersRemoved(false),
Mathias Agopian52bbb1a2012-07-31 19:01:53 -070092 mRepaintEverything(0),
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080093 mBootTime(systemTime()),
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080094 mVisibleRegionsDirty(false),
Mathias Agopiana350ff92010-08-10 17:14:02 -070095 mHwWorkListDirty(false),
Jamie Gennis4b0eba92013-02-05 13:30:24 -080096 mAnimCompositionPending(false),
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080097 mDebugRegion(0),
Mathias Agopian8afb7e32011-08-15 20:44:40 -070098 mDebugDDMS(0),
Mathias Agopian73d3ba92010-09-22 18:58:01 -070099 mDebugDisableHWC(0),
Mathias Agopiana4583642011-08-23 18:03:18 -0700100 mDebugDisableTransformHint(0),
Mathias Agopian9795c422009-08-26 16:36:26 -0700101 mDebugInSwapBuffers(0),
102 mLastSwapBufferTime(0),
103 mDebugInTransaction(0),
104 mLastTransactionTime(0),
Mathias Agopian5f20e2d2012-08-10 18:50:38 -0700105 mBootFinished(false)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800106{
Steve Blocka19954a2012-01-04 20:05:49 +0000107 ALOGI("SurfaceFlinger is starting");
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800108
109 // debugging stuff...
110 char value[PROPERTY_VALUE_MAX];
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700111
Mathias Agopianb4b17302013-03-20 18:36:41 -0700112 property_get("ro.bq.gpu_to_cpu_unsupported", value, "0");
Mathias Agopian50210b92013-03-21 21:13:21 -0700113 mGpuToCpuSupported = !atoi(value);
Mathias Agopianb4b17302013-03-20 18:36:41 -0700114
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800115 property_get("debug.sf.showupdates", value, "0");
116 mDebugRegion = atoi(value);
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700117
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700118 property_get("debug.sf.ddms", value, "0");
119 mDebugDDMS = atoi(value);
120 if (mDebugDDMS) {
Keun young Park63f165f2012-08-31 10:53:36 -0700121 if (!startDdmConnection()) {
122 // start failed, and DDMS debugging not enabled
123 mDebugDDMS = 0;
124 }
Mathias Agopian8afb7e32011-08-15 20:44:40 -0700125 }
Mathias Agopianc1d359d2012-08-04 20:09:03 -0700126 ALOGI_IF(mDebugRegion, "showupdates enabled");
127 ALOGI_IF(mDebugDDMS, "DDMS debugging enabled");
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800128}
129
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800130void SurfaceFlinger::onFirstRef()
131{
132 mEventQueue.init(this);
133
134 run("SurfaceFlinger", PRIORITY_URGENT_DISPLAY);
135
136 // Wait for the main thread to be done with its initialization
137 mReadyToRunBarrier.wait();
138}
139
140
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800141SurfaceFlinger::~SurfaceFlinger()
142{
Mathias Agopiana4912602012-07-12 14:25:33 -0700143 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
144 eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
145 eglTerminate(display);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800146}
147
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800148void SurfaceFlinger::binderDied(const wp<IBinder>& who)
149{
150 // the window manager died on us. prepare its eulogy.
151
Andy McFadden13a082e2012-08-24 10:16:42 -0700152 // restore initial conditions (default device unblank, etc)
153 initializeDisplays();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800154
155 // restart the boot-animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700156 startBootAnim();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800157}
158
Mathias Agopian7e27f052010-05-28 14:22:23 -0700159sp<ISurfaceComposerClient> SurfaceFlinger::createConnection()
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800160{
Mathias Agopian96f08192010-06-02 23:28:45 -0700161 sp<ISurfaceComposerClient> bclient;
162 sp<Client> client(new Client(this));
163 status_t err = client->initCheck();
164 if (err == NO_ERROR) {
165 bclient = client;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800166 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800167 return bclient;
168}
169
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700170sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName,
171 bool secure)
Mathias Agopiane57f2922012-08-09 16:29:12 -0700172{
173 class DisplayToken : public BBinder {
174 sp<SurfaceFlinger> flinger;
175 virtual ~DisplayToken() {
176 // no more references, this display must be terminated
177 Mutex::Autolock _l(flinger->mStateLock);
178 flinger->mCurrentState.displays.removeItem(this);
179 flinger->setTransactionFlags(eDisplayTransactionNeeded);
180 }
181 public:
182 DisplayToken(const sp<SurfaceFlinger>& flinger)
183 : flinger(flinger) {
184 }
185 };
186
187 sp<BBinder> token = new DisplayToken(this);
188
189 Mutex::Autolock _l(mStateLock);
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700190 DisplayDeviceState info(DisplayDevice::DISPLAY_VIRTUAL);
Andy McFadden8dfa92f2012-09-17 18:27:17 -0700191 info.displayName = displayName;
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700192 info.isSecure = secure;
Mathias Agopiane57f2922012-08-09 16:29:12 -0700193 mCurrentState.displays.add(token, info);
194
195 return token;
196}
197
Jesse Hall692c7232012-11-08 15:41:56 -0800198void SurfaceFlinger::createBuiltinDisplayLocked(DisplayDevice::DisplayType type) {
199 ALOGW_IF(mBuiltinDisplays[type],
200 "Overwriting display token for display type %d", type);
201 mBuiltinDisplays[type] = new BBinder();
202 DisplayDeviceState info(type);
203 // All non-virtual displays are currently considered secure.
204 info.isSecure = true;
205 mCurrentState.displays.add(mBuiltinDisplays[type], info);
206}
207
Mathias Agopiane57f2922012-08-09 16:29:12 -0700208sp<IBinder> SurfaceFlinger::getBuiltInDisplay(int32_t id) {
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700209 if (uint32_t(id) >= DisplayDevice::NUM_DISPLAY_TYPES) {
Mathias Agopiane57f2922012-08-09 16:29:12 -0700210 ALOGE("getDefaultDisplay: id=%d is not a valid default display id", id);
211 return NULL;
212 }
Jesse Hall692c7232012-11-08 15:41:56 -0800213 return mBuiltinDisplays[id];
Mathias Agopiane57f2922012-08-09 16:29:12 -0700214}
215
Jamie Gennis9a78c902011-01-12 18:30:40 -0800216sp<IGraphicBufferAlloc> SurfaceFlinger::createGraphicBufferAlloc()
217{
218 sp<GraphicBufferAlloc> gba(new GraphicBufferAlloc());
219 return gba;
220}
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700221
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800222void SurfaceFlinger::bootFinished()
223{
224 const nsecs_t now = systemTime();
225 const nsecs_t duration = now - mBootTime;
Steve Blocka19954a2012-01-04 20:05:49 +0000226 ALOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) );
Mathias Agopian3330b202009-10-05 17:07:12 -0700227 mBootFinished = true;
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700228
229 // wait patiently for the window manager death
230 const String16 name("window");
231 sp<IBinder> window(defaultServiceManager()->getService(name));
232 if (window != 0) {
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700233 window->linkToDeath(static_cast<IBinder::DeathRecipient*>(this));
Mathias Agopian1f339ff2011-07-01 17:08:43 -0700234 }
235
236 // stop boot animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700237 // formerly we would just kill the process, but we now ask it to exit so it
238 // can choose where to stop the animation.
239 property_set("service.bootanim.exit", "1");
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800240}
241
Mathias Agopian921e6ac2012-07-23 23:11:29 -0700242void SurfaceFlinger::deleteTextureAsync(GLuint texture) {
243 class MessageDestroyGLTexture : public MessageBase {
244 GLuint texture;
245 public:
246 MessageDestroyGLTexture(GLuint texture)
247 : texture(texture) {
248 }
249 virtual bool handler() {
250 glDeleteTextures(1, &texture);
251 return true;
252 }
253 };
254 postMessageAsync(new MessageDestroyGLTexture(texture));
255}
256
Mathias Agopian722b98f2012-09-25 18:24:31 -0700257status_t SurfaceFlinger::selectConfigForAttribute(
Mathias Agopiana4912602012-07-12 14:25:33 -0700258 EGLDisplay dpy,
259 EGLint const* attrs,
Mathias Agopian722b98f2012-09-25 18:24:31 -0700260 EGLint attribute, EGLint wanted,
Mathias Agopiana4912602012-07-12 14:25:33 -0700261 EGLConfig* outConfig)
262{
263 EGLConfig config = NULL;
264 EGLint numConfigs = -1, n=0;
265 eglGetConfigs(dpy, NULL, 0, &numConfigs);
266 EGLConfig* const configs = new EGLConfig[numConfigs];
267 eglChooseConfig(dpy, attrs, configs, numConfigs, &n);
Mathias Agopiancde87a32012-09-13 14:09:01 -0700268
Mathias Agopian722b98f2012-09-25 18:24:31 -0700269 if (n) {
270 if (attribute != EGL_NONE) {
271 for (int i=0 ; i<n ; i++) {
272 EGLint value = 0;
273 eglGetConfigAttrib(dpy, configs[i], attribute, &value);
274 if (wanted == value) {
275 *outConfig = configs[i];
276 delete [] configs;
277 return NO_ERROR;
278 }
279 }
280 } else {
281 // just pick the first one
282 *outConfig = configs[0];
Mathias Agopiana4912602012-07-12 14:25:33 -0700283 delete [] configs;
284 return NO_ERROR;
285 }
286 }
287 delete [] configs;
288 return NAME_NOT_FOUND;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800289}
290
Mathias Agopian722b98f2012-09-25 18:24:31 -0700291class EGLAttributeVector {
292 struct Attribute;
293 class Adder;
294 friend class Adder;
295 KeyedVector<Attribute, EGLint> mList;
296 struct Attribute {
297 Attribute() {};
298 Attribute(EGLint v) : v(v) { }
299 EGLint v;
300 bool operator < (const Attribute& other) const {
301 // this places EGL_NONE at the end
302 EGLint lhs(v);
303 EGLint rhs(other.v);
304 if (lhs == EGL_NONE) lhs = 0x7FFFFFFF;
305 if (rhs == EGL_NONE) rhs = 0x7FFFFFFF;
306 return lhs < rhs;
307 }
308 };
309 class Adder {
310 friend class EGLAttributeVector;
311 EGLAttributeVector& v;
312 EGLint attribute;
313 Adder(EGLAttributeVector& v, EGLint attribute)
314 : v(v), attribute(attribute) {
315 }
316 public:
317 void operator = (EGLint value) {
318 if (attribute != EGL_NONE) {
319 v.mList.add(attribute, value);
320 }
321 }
322 operator EGLint () const { return v.mList[attribute]; }
323 };
324public:
325 EGLAttributeVector() {
326 mList.add(EGL_NONE, EGL_NONE);
327 }
328 void remove(EGLint attribute) {
329 if (attribute != EGL_NONE) {
330 mList.removeItem(attribute);
331 }
332 }
333 Adder operator [] (EGLint attribute) {
334 return Adder(*this, attribute);
335 }
336 EGLint operator [] (EGLint attribute) const {
337 return mList[attribute];
338 }
339 // cast-operator to (EGLint const*)
340 operator EGLint const* () const { return &mList.keyAt(0).v; }
341};
342
Mathias Agopiana4912602012-07-12 14:25:33 -0700343EGLConfig SurfaceFlinger::selectEGLConfig(EGLDisplay display, EGLint nativeVisualId) {
344 // select our EGLConfig. It must support EGL_RECORDABLE_ANDROID if
345 // it is to be used with WIFI displays
346 EGLConfig config;
347 EGLint dummy;
348 status_t err;
Mathias Agopianda27af92012-09-13 18:17:13 -0700349
Mathias Agopian722b98f2012-09-25 18:24:31 -0700350 EGLAttributeVector attribs;
351 attribs[EGL_SURFACE_TYPE] = EGL_WINDOW_BIT;
352 attribs[EGL_RECORDABLE_ANDROID] = EGL_TRUE;
353 attribs[EGL_FRAMEBUFFER_TARGET_ANDROID] = EGL_TRUE;
354 attribs[EGL_RED_SIZE] = 8;
355 attribs[EGL_GREEN_SIZE] = 8;
356 attribs[EGL_BLUE_SIZE] = 8;
357
358 err = selectConfigForAttribute(display, attribs, EGL_NONE, EGL_NONE, &config);
359 if (!err)
360 goto success;
361
362 // maybe we failed because of EGL_FRAMEBUFFER_TARGET_ANDROID
363 ALOGW("no suitable EGLConfig found, trying without EGL_FRAMEBUFFER_TARGET_ANDROID");
364 attribs.remove(EGL_FRAMEBUFFER_TARGET_ANDROID);
365 err = selectConfigForAttribute(display, attribs,
366 EGL_NATIVE_VISUAL_ID, nativeVisualId, &config);
Jesse Hallf21cffa2012-09-19 21:00:49 -0700367 if (!err)
368 goto success;
369
370 // maybe we failed because of EGL_RECORDABLE_ANDROID
371 ALOGW("no suitable EGLConfig found, trying without EGL_RECORDABLE_ANDROID");
Mathias Agopian722b98f2012-09-25 18:24:31 -0700372 attribs.remove(EGL_RECORDABLE_ANDROID);
373 err = selectConfigForAttribute(display, attribs,
374 EGL_NATIVE_VISUAL_ID, nativeVisualId, &config);
Jesse Hallf21cffa2012-09-19 21:00:49 -0700375 if (!err)
376 goto success;
377
378 // allow less than 24-bit color; the non-gpu-accelerated emulator only
379 // supports 16-bit color
380 ALOGW("no suitable EGLConfig found, trying with 16-bit color allowed");
Mathias Agopian722b98f2012-09-25 18:24:31 -0700381 attribs.remove(EGL_RED_SIZE);
382 attribs.remove(EGL_GREEN_SIZE);
383 attribs.remove(EGL_BLUE_SIZE);
384 err = selectConfigForAttribute(display, attribs,
385 EGL_NATIVE_VISUAL_ID, nativeVisualId, &config);
Jesse Hallf21cffa2012-09-19 21:00:49 -0700386 if (!err)
387 goto success;
388
389 // this EGL is too lame for Android
390 ALOGE("no suitable EGLConfig found, giving up");
391
392 return 0;
393
394success:
395 if (eglGetConfigAttrib(display, config, EGL_CONFIG_CAVEAT, &dummy))
Mathias Agopiana4912602012-07-12 14:25:33 -0700396 ALOGW_IF(dummy == EGL_SLOW_CONFIG, "EGL_SLOW_CONFIG selected!");
Mathias Agopiana4912602012-07-12 14:25:33 -0700397 return config;
398}
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800399
Mathias Agopiana4912602012-07-12 14:25:33 -0700400EGLContext SurfaceFlinger::createGLContext(EGLDisplay display, EGLConfig config) {
401 // Also create our EGLContext
402 EGLint contextAttributes[] = {
403#ifdef EGL_IMG_context_priority
404#ifdef HAS_CONTEXT_PRIORITY
405#warning "using EGL_IMG_context_priority"
406 EGL_CONTEXT_PRIORITY_LEVEL_IMG, EGL_CONTEXT_PRIORITY_HIGH_IMG,
407#endif
408#endif
409 EGL_NONE, EGL_NONE
410 };
411 EGLContext ctxt = eglCreateContext(display, config, NULL, contextAttributes);
412 ALOGE_IF(ctxt==EGL_NO_CONTEXT, "EGLContext creation failed");
413 return ctxt;
414}
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800415
Mathias Agopiancde87a32012-09-13 14:09:01 -0700416void SurfaceFlinger::initializeGL(EGLDisplay display) {
Mathias Agopiana4912602012-07-12 14:25:33 -0700417 GLExtensions& extensions(GLExtensions::getInstance());
418 extensions.initWithGLStrings(
419 glGetString(GL_VENDOR),
420 glGetString(GL_RENDERER),
421 glGetString(GL_VERSION),
422 glGetString(GL_EXTENSIONS),
423 eglQueryString(display, EGL_VENDOR),
424 eglQueryString(display, EGL_VERSION),
425 eglQueryString(display, EGL_EXTENSIONS));
Andreas Huber8b42e8a2010-08-16 08:49:37 -0700426
Mathias Agopiana4912602012-07-12 14:25:33 -0700427 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize);
428 glGetIntegerv(GL_MAX_VIEWPORT_DIMS, mMaxViewportDims);
Mathias Agopian7303c6b2009-07-02 18:11:53 -0700429
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800430 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
Andreas Huber8b42e8a2010-08-16 08:49:37 -0700431 glPixelStorei(GL_PACK_ALIGNMENT, 4);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800432 glEnableClientState(GL_VERTEX_ARRAY);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800433 glShadeModel(GL_FLAT);
434 glDisable(GL_DITHER);
435 glDisable(GL_CULL_FACE);
436
Mathias Agopiana4912602012-07-12 14:25:33 -0700437 struct pack565 {
438 inline uint16_t operator() (int r, int g, int b) const {
439 return (r<<11)|(g<<5)|b;
440 }
441 } pack565;
442
Jamie Gennis9575f602011-10-07 14:51:16 -0700443 const uint16_t protTexData[] = { pack565(0x03, 0x03, 0x03) };
444 glGenTextures(1, &mProtectedTexName);
445 glBindTexture(GL_TEXTURE_2D, mProtectedTexName);
446 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
447 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
448 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
449 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
450 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0,
451 GL_RGB, GL_UNSIGNED_SHORT_5_6_5, protTexData);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800452
Mathias Agopiana4912602012-07-12 14:25:33 -0700453 // print some debugging info
454 EGLint r,g,b,a;
455 eglGetConfigAttrib(display, mEGLConfig, EGL_RED_SIZE, &r);
456 eglGetConfigAttrib(display, mEGLConfig, EGL_GREEN_SIZE, &g);
457 eglGetConfigAttrib(display, mEGLConfig, EGL_BLUE_SIZE, &b);
458 eglGetConfigAttrib(display, mEGLConfig, EGL_ALPHA_SIZE, &a);
459 ALOGI("EGL informations:");
460 ALOGI("vendor : %s", extensions.getEglVendor());
461 ALOGI("version : %s", extensions.getEglVersion());
462 ALOGI("extensions: %s", extensions.getEglExtension());
463 ALOGI("Client API: %s", eglQueryString(display, EGL_CLIENT_APIS)?:"Not Supported");
464 ALOGI("EGLSurface: %d-%d-%d-%d, config=%p", r, g, b, a, mEGLConfig);
465 ALOGI("OpenGL ES informations:");
466 ALOGI("vendor : %s", extensions.getVendor());
467 ALOGI("renderer : %s", extensions.getRenderer());
468 ALOGI("version : %s", extensions.getVersion());
469 ALOGI("extensions: %s", extensions.getExtension());
470 ALOGI("GL_MAX_TEXTURE_SIZE = %d", mMaxTextureSize);
471 ALOGI("GL_MAX_VIEWPORT_DIMS = %d x %d", mMaxViewportDims[0], mMaxViewportDims[1]);
472}
473
Mathias Agopiana4912602012-07-12 14:25:33 -0700474status_t SurfaceFlinger::readyToRun()
475{
476 ALOGI( "SurfaceFlinger's main thread ready to run. "
477 "Initializing graphics H/W...");
478
Jesse Hall692c7232012-11-08 15:41:56 -0800479 Mutex::Autolock _l(mStateLock);
480
Andy McFaddenb0d1dd32012-09-10 14:08:09 -0700481 // initialize EGL for the default display
Jesse Hall34a09ba2012-07-29 22:35:34 -0700482 mEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
483 eglInitialize(mEGLDisplay, NULL, NULL);
Mathias Agopiana4912602012-07-12 14:25:33 -0700484
Andy McFaddenb0d1dd32012-09-10 14:08:09 -0700485 // Initialize the H/W composer object. There may or may not be an
486 // actual hardware composer underneath.
487 mHwc = new HWComposer(this,
488 *static_cast<HWComposer::EventHandler *>(this));
489
Mathias Agopiana4912602012-07-12 14:25:33 -0700490 // initialize the config and context
Mathias Agopiancde87a32012-09-13 14:09:01 -0700491 EGLint format = mHwc->getVisualID();
Jesse Hall34a09ba2012-07-29 22:35:34 -0700492 mEGLConfig = selectEGLConfig(mEGLDisplay, format);
493 mEGLContext = createGLContext(mEGLDisplay, mEGLConfig);
Mathias Agopiana4912602012-07-12 14:25:33 -0700494
Mathias Agopianed985572013-03-22 00:24:39 -0700495 // figure out which format we got
496 eglGetConfigAttrib(mEGLDisplay, mEGLConfig,
497 EGL_NATIVE_VISUAL_ID, &mEGLNativeVisualId);
498
Mathias Agopianda27af92012-09-13 18:17:13 -0700499 LOG_ALWAYS_FATAL_IF(mEGLContext == EGL_NO_CONTEXT,
500 "couldn't create EGLContext");
501
Mathias Agopiancde87a32012-09-13 14:09:01 -0700502 // initialize our non-virtual displays
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700503 for (size_t i=0 ; i<DisplayDevice::NUM_DISPLAY_TYPES ; i++) {
Mathias Agopianf5a33922012-09-19 18:16:22 -0700504 DisplayDevice::DisplayType type((DisplayDevice::DisplayType)i);
Mathias Agopianf5a33922012-09-19 18:16:22 -0700505 // set-up the displays that are already connected
Mathias Agopian9e2463e2012-09-21 18:26:16 -0700506 if (mHwc->isConnected(i) || type==DisplayDevice::DISPLAY_PRIMARY) {
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700507 // All non-virtual displays are currently considered secure.
508 bool isSecure = true;
Jesse Hall692c7232012-11-08 15:41:56 -0800509 createBuiltinDisplayLocked(type);
510 wp<IBinder> token = mBuiltinDisplays[i];
511
Mathias Agopianf5a33922012-09-19 18:16:22 -0700512 sp<DisplayDevice> hw = new DisplayDevice(this,
Jesse Hallffe1f192013-03-22 15:13:48 -0700513 type, allocateHwcDisplayId(type), isSecure, token,
514 new FramebufferSurface(*mHwc, i),
Jesse Hall99c7dbb2013-03-14 14:29:29 -0700515 mEGLConfig);
Mathias Agopianf5a33922012-09-19 18:16:22 -0700516 if (i > DisplayDevice::DISPLAY_PRIMARY) {
Andy McFaddenc01a79d2012-09-27 16:02:06 -0700517 // FIXME: currently we don't get blank/unblank requests
Mathias Agopianf5a33922012-09-19 18:16:22 -0700518 // for displays other than the main display, so we always
519 // assume a connected display is unblanked.
Andy McFaddenc01a79d2012-09-27 16:02:06 -0700520 ALOGD("marking display %d as acquired/unblanked", i);
Mathias Agopianf5a33922012-09-19 18:16:22 -0700521 hw->acquireScreen();
522 }
523 mDisplays.add(token, hw);
524 }
Mathias Agopiane57f2922012-08-09 16:29:12 -0700525 }
Mathias Agopiancde87a32012-09-13 14:09:01 -0700526
Mathias Agopianf5a33922012-09-19 18:16:22 -0700527 // we need a GL context current in a few places, when initializing
528 // OpenGL ES (see below), or creating a layer,
529 // or when a texture is (asynchronously) destroyed, and for that
530 // we need a valid surface, so it's convenient to use the main display
531 // for that.
Mathias Agopiandb9b41f2012-10-15 16:51:41 -0700532 sp<const DisplayDevice> hw(getDefaultDisplayDevice());
Mathias Agopiancde87a32012-09-13 14:09:01 -0700533
Mathias Agopiana4912602012-07-12 14:25:33 -0700534 // initialize OpenGL ES
Mathias Agopiancde87a32012-09-13 14:09:01 -0700535 DisplayDevice::makeCurrent(mEGLDisplay, hw, mEGLContext);
536 initializeGL(mEGLDisplay);
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800537
Mathias Agopian028508c2012-07-25 21:12:12 -0700538 // start the EventThread
539 mEventThread = new EventThread(this);
540 mEventQueue.setEventThread(mEventThread);
541
Mathias Agopian92a979a2012-08-02 18:32:23 -0700542 // initialize our drawing state
543 mDrawingState = mCurrentState;
Mathias Agopian86303202012-07-24 22:46:10 -0700544
Mathias Agopiancde87a32012-09-13 14:09:01 -0700545
Mathias Agopiana4912602012-07-12 14:25:33 -0700546 // We're now ready to accept clients...
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800547 mReadyToRunBarrier.open();
548
Andy McFadden13a082e2012-08-24 10:16:42 -0700549 // set initial conditions (e.g. unblank default device)
550 initializeDisplays();
551
Mathias Agopiana1ecca92009-05-21 19:21:59 -0700552 // start boot animation
Mathias Agopiana67e4182012-06-19 17:26:12 -0700553 startBootAnim();
Andreas Huber8b42e8a2010-08-16 08:49:37 -0700554
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800555 return NO_ERROR;
556}
557
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700558int32_t SurfaceFlinger::allocateHwcDisplayId(DisplayDevice::DisplayType type) {
559 return (uint32_t(type) < DisplayDevice::NUM_DISPLAY_TYPES) ?
560 type : mHwc->allocateDisplayId();
561}
562
Mathias Agopiana67e4182012-06-19 17:26:12 -0700563void SurfaceFlinger::startBootAnim() {
564 // start boot animation
565 property_set("service.bootanim.exit", "0");
566 property_set("ctl.start", "bootanim");
567}
568
Mathias Agopiana4912602012-07-12 14:25:33 -0700569uint32_t SurfaceFlinger::getMaxTextureSize() const {
570 return mMaxTextureSize;
571}
572
573uint32_t SurfaceFlinger::getMaxViewportDims() const {
574 return mMaxViewportDims[0] < mMaxViewportDims[1] ?
575 mMaxViewportDims[0] : mMaxViewportDims[1];
576}
577
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800578// ----------------------------------------------------------------------------
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800579
Jamie Gennis582270d2011-08-17 18:19:00 -0700580bool SurfaceFlinger::authenticateSurfaceTexture(
Andy McFadden2adaf042012-12-18 09:49:45 -0800581 const sp<IGraphicBufferProducer>& bufferProducer) const {
Jamie Gennis134f0422011-03-08 12:18:54 -0800582 Mutex::Autolock _l(mStateLock);
Andy McFadden2adaf042012-12-18 09:49:45 -0800583 sp<IBinder> surfaceTextureBinder(bufferProducer->asBinder());
Mathias Agopian67106042013-03-14 19:18:13 -0700584 return mGraphicBufferProducerList.indexOf(surfaceTextureBinder) >= 0;
Jamie Gennis134f0422011-03-08 12:18:54 -0800585}
586
Jeff Brown9d4e3d22012-08-24 20:00:51 -0700587status_t SurfaceFlinger::getDisplayInfo(const sp<IBinder>& display, DisplayInfo* info) {
Jesse Hall692c7232012-11-08 15:41:56 -0800588 int32_t type = NAME_NOT_FOUND;
Mathias Agopian1604f772012-09-18 21:54:42 -0700589 for (int i=0 ; i<DisplayDevice::NUM_DISPLAY_TYPES ; i++) {
Jesse Hall692c7232012-11-08 15:41:56 -0800590 if (display == mBuiltinDisplays[i]) {
Mathias Agopian1604f772012-09-18 21:54:42 -0700591 type = i;
592 break;
593 }
594 }
595
596 if (type < 0) {
597 return type;
Mathias Agopianc666cae2012-07-25 18:56:13 -0700598 }
Mathias Agopian8b736f12012-08-13 17:54:26 -0700599
600 const HWComposer& hwc(getHwComposer());
Mathias Agopian1604f772012-09-18 21:54:42 -0700601 float xdpi = hwc.getDpiX(type);
602 float ydpi = hwc.getDpiY(type);
Mathias Agopian8b736f12012-08-13 17:54:26 -0700603
604 // TODO: Not sure if display density should handled by SF any longer
605 class Density {
606 static int getDensityFromProperty(char const* propName) {
607 char property[PROPERTY_VALUE_MAX];
608 int density = 0;
609 if (property_get(propName, property, NULL) > 0) {
610 density = atoi(property);
611 }
612 return density;
613 }
614 public:
615 static int getEmuDensity() {
616 return getDensityFromProperty("qemu.sf.lcd_density"); }
617 static int getBuildDensity() {
618 return getDensityFromProperty("ro.sf.lcd_density"); }
619 };
Mathias Agopian1604f772012-09-18 21:54:42 -0700620
621 if (type == DisplayDevice::DISPLAY_PRIMARY) {
622 // The density of the device is provided by a build property
623 float density = Density::getBuildDensity() / 160.0f;
624 if (density == 0) {
625 // the build doesn't provide a density -- this is wrong!
626 // use xdpi instead
627 ALOGE("ro.sf.lcd_density must be defined as a build property");
628 density = xdpi / 160.0f;
629 }
630 if (Density::getEmuDensity()) {
631 // if "qemu.sf.lcd_density" is specified, it overrides everything
632 xdpi = ydpi = density = Density::getEmuDensity();
633 density /= 160.0f;
634 }
635 info->density = density;
636
637 // TODO: this needs to go away (currently needed only by webkit)
638 sp<const DisplayDevice> hw(getDefaultDisplayDevice());
639 info->orientation = hw->getOrientation();
640 getPixelFormatInfo(hw->getFormat(), &info->pixelFormatInfo);
641 } else {
642 // TODO: where should this value come from?
643 static const int TV_DENSITY = 213;
644 info->density = TV_DENSITY / 160.0f;
645 info->orientation = 0;
Mathias Agopian8b736f12012-08-13 17:54:26 -0700646 }
647
Mathias Agopian1604f772012-09-18 21:54:42 -0700648 info->w = hwc.getWidth(type);
649 info->h = hwc.getHeight(type);
Mathias Agopian8b736f12012-08-13 17:54:26 -0700650 info->xdpi = xdpi;
651 info->ydpi = ydpi;
Mathias Agopian1604f772012-09-18 21:54:42 -0700652 info->fps = float(1e9 / hwc.getRefreshPeriod(type));
Jamie Gennisdd3cb842012-10-19 18:19:11 -0700653
654 // All non-virtual displays are currently considered secure.
655 info->secure = true;
656
Mathias Agopian888c8222012-08-04 21:10:38 -0700657 return NO_ERROR;
Mathias Agopianc666cae2012-07-25 18:56:13 -0700658}
659
Mathias Agopiand0566bc2011-11-17 17:49:17 -0800660// ----------------------------------------------------------------------------
661
662sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection() {
Mathias Agopian8aedd472012-01-24 16:39:14 -0800663 return mEventThread->createEventConnection();
Mathias Agopianbb641242010-05-18 17:06:55 -0700664}
665
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800666// ----------------------------------------------------------------------------
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800667
668void SurfaceFlinger::waitForEvent() {
669 mEventQueue.waitMessage();
670}
671
672void SurfaceFlinger::signalTransaction() {
673 mEventQueue.invalidate();
674}
675
676void SurfaceFlinger::signalLayerUpdate() {
677 mEventQueue.invalidate();
678}
679
680void SurfaceFlinger::signalRefresh() {
681 mEventQueue.refresh();
682}
683
684status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg,
685 nsecs_t reltime, uint32_t flags) {
686 return mEventQueue.postMessage(msg, reltime);
687}
688
689status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,
690 nsecs_t reltime, uint32_t flags) {
691 status_t res = mEventQueue.postMessage(msg, reltime);
692 if (res == NO_ERROR) {
693 msg->wait();
694 }
695 return res;
696}
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800697
Mathias Agopian4fec8732012-06-29 14:12:52 -0700698bool SurfaceFlinger::threadLoop() {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800699 waitForEvent();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800700 return true;
701}
702
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700703void SurfaceFlinger::onVSyncReceived(int type, nsecs_t timestamp) {
Andy McFadden43601a22012-09-11 15:15:13 -0700704 if (mEventThread == NULL) {
705 // This is a temporary workaround for b/7145521. A non-null pointer
706 // does not mean EventThread has finished initializing, so this
707 // is not a correct fix.
708 ALOGW("WARNING: EventThread not started, ignoring vsync");
709 return;
710 }
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700711 if (uint32_t(type) < DisplayDevice::NUM_DISPLAY_TYPES) {
712 // we should only receive DisplayDevice::DisplayType from the vsync callback
Mathias Agopian148994e2012-09-19 17:31:36 -0700713 mEventThread->onVSyncReceived(type, timestamp);
714 }
715}
716
717void SurfaceFlinger::onHotplugReceived(int type, bool connected) {
718 if (mEventThread == NULL) {
719 // This is a temporary workaround for b/7145521. A non-null pointer
720 // does not mean EventThread has finished initializing, so this
721 // is not a correct fix.
722 ALOGW("WARNING: EventThread not started, ignoring hotplug");
723 return;
724 }
Mathias Agopian9e2463e2012-09-21 18:26:16 -0700725
Mathias Agopian148994e2012-09-19 17:31:36 -0700726 if (uint32_t(type) < DisplayDevice::NUM_DISPLAY_TYPES) {
Mathias Agopian9e2463e2012-09-21 18:26:16 -0700727 Mutex::Autolock _l(mStateLock);
Jesse Hall692c7232012-11-08 15:41:56 -0800728 if (connected) {
729 createBuiltinDisplayLocked((DisplayDevice::DisplayType)type);
Mathias Agopian9e2463e2012-09-21 18:26:16 -0700730 } else {
Jesse Hall692c7232012-11-08 15:41:56 -0800731 mCurrentState.displays.removeItem(mBuiltinDisplays[type]);
732 mBuiltinDisplays[type].clear();
Mathias Agopian9e2463e2012-09-21 18:26:16 -0700733 }
734 setTransactionFlags(eDisplayTransactionNeeded);
735
Andy McFadden9e9689c2012-10-10 18:17:51 -0700736 // Defer EventThread notification until SF has updated mDisplays.
Mathias Agopian3ee454a2012-08-27 16:28:24 -0700737 }
Mathias Agopian86303202012-07-24 22:46:10 -0700738}
739
Mathias Agopian81cd5d32012-10-04 02:34:38 -0700740void SurfaceFlinger::eventControl(int disp, int event, int enabled) {
741 getHwComposer().eventControl(disp, event, enabled);
Mathias Agopian86303202012-07-24 22:46:10 -0700742}
743
Mathias Agopian4fec8732012-06-29 14:12:52 -0700744void SurfaceFlinger::onMessageReceived(int32_t what) {
Jamie Gennis1c8e95c2012-02-23 19:27:23 -0800745 ATRACE_CALL();
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800746 switch (what) {
Mathias Agopian4fec8732012-06-29 14:12:52 -0700747 case MessageQueue::INVALIDATE:
748 handleMessageTransaction();
749 handleMessageInvalidate();
750 signalRefresh();
751 break;
752 case MessageQueue::REFRESH:
753 handleMessageRefresh();
754 break;
Mathias Agopian99ce5cd2012-01-31 18:24:27 -0800755 }
756}
757
Mathias Agopian4fec8732012-06-29 14:12:52 -0700758void SurfaceFlinger::handleMessageTransaction() {
Mathias Agopiane57f2922012-08-09 16:29:12 -0700759 uint32_t transactionFlags = peekTransactionFlags(eTransactionMask);
Mathias Agopian4fec8732012-06-29 14:12:52 -0700760 if (transactionFlags) {
Mathias Agopian87baae12012-07-31 12:38:26 -0700761 handleTransaction(transactionFlags);
Mathias Agopian4fec8732012-06-29 14:12:52 -0700762 }
763}
764
765void SurfaceFlinger::handleMessageInvalidate() {
Mathias Agopiancd60f992012-08-16 16:28:27 -0700766 ATRACE_CALL();
Mathias Agopian87baae12012-07-31 12:38:26 -0700767 handlePageFlip();
Mathias Agopian4fec8732012-06-29 14:12:52 -0700768}
769
770void SurfaceFlinger::handleMessageRefresh() {
Mathias Agopiancd60f992012-08-16 16:28:27 -0700771 ATRACE_CALL();
772 preComposition();
773 rebuildLayerStacks();
774 setUpHWComposer();
775 doDebugFlashRegions();
776 doComposition();
777 postComposition();
778}
Mathias Agopian4fec8732012-06-29 14:12:52 -0700779
Mathias Agopiancd60f992012-08-16 16:28:27 -0700780void SurfaceFlinger::doDebugFlashRegions()
781{
782 // is debugging enabled
783 if (CC_LIKELY(!mDebugRegion))
784 return;
785
786 const bool repaintEverything = mRepaintEverything;
787 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
788 const sp<DisplayDevice>& hw(mDisplays[dpy]);
789 if (hw->canDraw()) {
790 // transform the dirty region into this screen's coordinate space
791 const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));
792 if (!dirtyRegion.isEmpty()) {
793 // redraw the whole screen
794 doComposeSurfaces(hw, Region(hw->bounds()));
795
796 // and draw the dirty region
797 glDisable(GL_TEXTURE_EXTERNAL_OES);
798 glDisable(GL_TEXTURE_2D);
799 glDisable(GL_BLEND);
800 glColor4f(1, 0, 1, 1);
801 const int32_t height = hw->getHeight();
802 Region::const_iterator it = dirtyRegion.begin();
803 Region::const_iterator const end = dirtyRegion.end();
804 while (it != end) {
805 const Rect& r = *it++;
806 GLfloat vertices[][2] = {
Andy McFadden8f06a8c2013-01-11 10:24:34 -0800807 { (GLfloat) r.left, (GLfloat) (height - r.top) },
808 { (GLfloat) r.left, (GLfloat) (height - r.bottom) },
809 { (GLfloat) r.right, (GLfloat) (height - r.bottom) },
810 { (GLfloat) r.right, (GLfloat) (height - r.top) }
Mathias Agopiancd60f992012-08-16 16:28:27 -0700811 };
812 glVertexPointer(2, GL_FLOAT, 0, vertices);
813 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
814 }
815 hw->compositionComplete();
Mathias Agopianda27af92012-09-13 18:17:13 -0700816 hw->swapBuffers(getHwComposer());
Mathias Agopiancd60f992012-08-16 16:28:27 -0700817 }
818 }
819 }
820
821 postFramebuffer();
822
823 if (mDebugRegion > 1) {
824 usleep(mDebugRegion * 1000);
825 }
Mathias Agopianbb53b0e2012-09-24 21:27:29 -0700826
827 HWComposer& hwc(getHwComposer());
828 if (hwc.initCheck() == NO_ERROR) {
829 status_t err = hwc.prepare();
830 ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err));
831 }
Mathias Agopiancd60f992012-08-16 16:28:27 -0700832}
833
834void SurfaceFlinger::preComposition()
835{
836 bool needExtraInvalidate = false;
837 const LayerVector& currentLayers(mDrawingState.layersSortedByZ);
838 const size_t count = currentLayers.size();
839 for (size_t i=0 ; i<count ; i++) {
840 if (currentLayers[i]->onPreComposition()) {
841 needExtraInvalidate = true;
842 }
843 }
844 if (needExtraInvalidate) {
845 signalLayerUpdate();
846 }
847}
848
849void SurfaceFlinger::postComposition()
850{
851 const LayerVector& currentLayers(mDrawingState.layersSortedByZ);
852 const size_t count = currentLayers.size();
853 for (size_t i=0 ; i<count ; i++) {
854 currentLayers[i]->onPostComposition();
855 }
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800856
857 if (mAnimCompositionPending) {
858 mAnimCompositionPending = false;
859
860 const HWComposer& hwc = getHwComposer();
861 sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY);
Jesse Halla9a1b002013-02-27 16:39:25 -0800862 if (presentFence->isValid()) {
Jamie Gennis4b0eba92013-02-05 13:30:24 -0800863 mAnimFrameTracker.setActualPresentFence(presentFence);
864 } else {
865 // The HWC doesn't support present fences, so use the refresh
866 // timestamp instead.
867 nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY);
868 mAnimFrameTracker.setActualPresentTime(presentTime);
869 }
870 mAnimFrameTracker.advanceFrame();
871 }
Mathias Agopiancd60f992012-08-16 16:28:27 -0700872}
873
874void SurfaceFlinger::rebuildLayerStacks() {
875 // rebuild the visible layer list per screen
Mathias Agopian52bbb1a2012-07-31 19:01:53 -0700876 if (CC_UNLIKELY(mVisibleRegionsDirty)) {
Mathias Agopiancd60f992012-08-16 16:28:27 -0700877 ATRACE_CALL();
Mathias Agopian87baae12012-07-31 12:38:26 -0700878 mVisibleRegionsDirty = false;
879 invalidateHwcGeometry();
Mathias Agopiance3a0a52012-09-12 15:34:57 -0700880
Mathias Agopian87baae12012-07-31 12:38:26 -0700881 const LayerVector& currentLayers(mDrawingState.layersSortedByZ);
Mathias Agopian92a979a2012-08-02 18:32:23 -0700882 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
Mathias Agopiance3a0a52012-09-12 15:34:57 -0700883 Region opaqueRegion;
884 Region dirtyRegion;
Mathias Agopian13127d82013-03-05 17:47:11 -0800885 Vector< sp<Layer> > layersSortedByZ;
Mathias Agopian42977342012-08-05 00:40:46 -0700886 const sp<DisplayDevice>& hw(mDisplays[dpy]);
Mathias Agopian7e7ed7f2012-08-28 14:20:00 -0700887 const Transform& tr(hw->getTransform());
888 const Rect bounds(hw->getBounds());
Mathias Agopiance3a0a52012-09-12 15:34:57 -0700889 if (hw->canDraw()) {
890 SurfaceFlinger::computeVisibleRegions(currentLayers,
891 hw->getLayerStack(), dirtyRegion, opaqueRegion);
Mathias Agopian7e7ed7f2012-08-28 14:20:00 -0700892
Mathias Agopiance3a0a52012-09-12 15:34:57 -0700893 const size_t count = currentLayers.size();
894 for (size_t i=0 ; i<count ; i++) {
Mathias Agopian13127d82013-03-05 17:47:11 -0800895 const sp<Layer>& layer(currentLayers[i]);
Mathias Agopiance3a0a52012-09-12 15:34:57 -0700896 const Layer::State& s(layer->drawingState());
897 if (s.layerStack == hw->getLayerStack()) {
Jesse Halla8026d22012-09-25 13:25:04 -0700898 Region drawRegion(tr.transform(
899 layer->visibleNonTransparentRegion));
900 drawRegion.andSelf(bounds);
901 if (!drawRegion.isEmpty()) {
Mathias Agopiance3a0a52012-09-12 15:34:57 -0700902 layersSortedByZ.add(layer);
903 }
Mathias Agopian87baae12012-07-31 12:38:26 -0700904 }
905 }
Mathias Agopian3b1d2b62012-07-11 13:48:17 -0700906 }
Mathias Agopian42977342012-08-05 00:40:46 -0700907 hw->setVisibleLayersSortedByZ(layersSortedByZ);
Mathias Agopian7e7ed7f2012-08-28 14:20:00 -0700908 hw->undefinedRegion.set(bounds);
909 hw->undefinedRegion.subtractSelf(tr.transform(opaqueRegion));
910 hw->dirtyRegion.orSelf(dirtyRegion);
Mathias Agopian3b1d2b62012-07-11 13:48:17 -0700911 }
Mathias Agopian3b1d2b62012-07-11 13:48:17 -0700912 }
Mathias Agopiancd60f992012-08-16 16:28:27 -0700913}
Mathias Agopian3b1d2b62012-07-11 13:48:17 -0700914
Mathias Agopiancd60f992012-08-16 16:28:27 -0700915void SurfaceFlinger::setUpHWComposer() {
Mathias Agopian52bbb1a2012-07-31 19:01:53 -0700916 HWComposer& hwc(getHwComposer());
917 if (hwc.initCheck() == NO_ERROR) {
918 // build the h/w work list
Jamie Gennisa4310c82012-09-25 20:26:00 -0700919 if (CC_UNLIKELY(mHwWorkListDirty)) {
920 mHwWorkListDirty = false;
921 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
922 sp<const DisplayDevice> hw(mDisplays[dpy]);
923 const int32_t id = hw->getHwcDisplayId();
924 if (id >= 0) {
Mathias Agopian13127d82013-03-05 17:47:11 -0800925 const Vector< sp<Layer> >& currentLayers(
Jamie Gennisa4310c82012-09-25 20:26:00 -0700926 hw->getVisibleLayersSortedByZ());
927 const size_t count = currentLayers.size();
928 if (hwc.createWorkList(id, count) == NO_ERROR) {
929 HWComposer::LayerListIterator cur = hwc.begin(id);
930 const HWComposer::LayerListIterator end = hwc.end(id);
931 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
Mathias Agopian13127d82013-03-05 17:47:11 -0800932 const sp<Layer>& layer(currentLayers[i]);
Jamie Gennisa4310c82012-09-25 20:26:00 -0700933 layer->setGeometry(hw, *cur);
934 if (mDebugDisableHWC || mDebugRegion) {
935 cur->setSkip(true);
936 }
937 }
938 }
939 }
940 }
941 }
942
943 // set the per-frame data
Mathias Agopian92a979a2012-08-02 18:32:23 -0700944 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
Mathias Agopian42977342012-08-05 00:40:46 -0700945 sp<const DisplayDevice> hw(mDisplays[dpy]);
Mathias Agopiane60b0682012-08-21 23:34:09 -0700946 const int32_t id = hw->getHwcDisplayId();
947 if (id >= 0) {
Mathias Agopian13127d82013-03-05 17:47:11 -0800948 const Vector< sp<Layer> >& currentLayers(
Mathias Agopiancd60f992012-08-16 16:28:27 -0700949 hw->getVisibleLayersSortedByZ());
Mathias Agopiane60b0682012-08-21 23:34:09 -0700950 const size_t count = currentLayers.size();
Jamie Gennisa4310c82012-09-25 20:26:00 -0700951 HWComposer::LayerListIterator cur = hwc.begin(id);
952 const HWComposer::LayerListIterator end = hwc.end(id);
953 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
954 /*
955 * update the per-frame h/w composer data for each layer
956 * and build the transparent region of the FB
957 */
Mathias Agopian13127d82013-03-05 17:47:11 -0800958 const sp<Layer>& layer(currentLayers[i]);
Jamie Gennisa4310c82012-09-25 20:26:00 -0700959 layer->setPerFrameData(hw, *cur);
Mathias Agopian1e260872012-08-08 18:35:12 -0700960 }
Mathias Agopian52bbb1a2012-07-31 19:01:53 -0700961 }
Mathias Agopian87baae12012-07-31 12:38:26 -0700962 }
Jamie Gennisa4310c82012-09-25 20:26:00 -0700963
Mathias Agopian52bbb1a2012-07-31 19:01:53 -0700964 status_t err = hwc.prepare();
965 ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err));
966 }
Mathias Agopiancd60f992012-08-16 16:28:27 -0700967}
Mathias Agopian52bbb1a2012-07-31 19:01:53 -0700968
Mathias Agopiancd60f992012-08-16 16:28:27 -0700969void SurfaceFlinger::doComposition() {
970 ATRACE_CALL();
Mathias Agopian52bbb1a2012-07-31 19:01:53 -0700971 const bool repaintEverything = android_atomic_and(0, &mRepaintEverything);
Mathias Agopian92a979a2012-08-02 18:32:23 -0700972 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
Mathias Agopian42977342012-08-05 00:40:46 -0700973 const sp<DisplayDevice>& hw(mDisplays[dpy]);
Mathias Agopiancd60f992012-08-16 16:28:27 -0700974 if (hw->canDraw()) {
975 // transform the dirty region into this screen's coordinate space
976 const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));
Mathias Agopian02b95102012-11-05 17:50:57 -0800977
978 // repaint the framebuffer (if needed)
979 doDisplayComposition(hw, dirtyRegion);
980
Mathias Agopiancd60f992012-08-16 16:28:27 -0700981 hw->dirtyRegion.clear();
982 hw->flip(hw->swapRegion);
983 hw->swapRegion.clear();
Mathias Agopian87baae12012-07-31 12:38:26 -0700984 }
Mathias Agopian52bbb1a2012-07-31 19:01:53 -0700985 // inform the h/w that we're done compositing
Mathias Agopian42977342012-08-05 00:40:46 -0700986 hw->compositionComplete();
Mathias Agopian4fec8732012-06-29 14:12:52 -0700987 }
Mathias Agopian52bbb1a2012-07-31 19:01:53 -0700988 postFramebuffer();
Mathias Agopian4fec8732012-06-29 14:12:52 -0700989}
990
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800991void SurfaceFlinger::postFramebuffer()
992{
Mathias Agopian841cde52012-03-01 15:44:37 -0800993 ATRACE_CALL();
Mathias Agopianb048cef2012-02-04 15:44:04 -0800994
Mathias Agopiana44b0412011-10-16 18:46:35 -0700995 const nsecs_t now = systemTime();
996 mDebugInSwapBuffers = now;
Jesse Hallc5c5a142012-07-02 16:49:28 -0700997
Mathias Agopian52bbb1a2012-07-31 19:01:53 -0700998 HWComposer& hwc(getHwComposer());
Jesse Hallef194142012-06-14 14:45:17 -0700999 if (hwc.initCheck() == NO_ERROR) {
Mathias Agopian2a231842012-09-24 18:12:35 -07001000 if (!hwc.supportsFramebufferTarget()) {
1001 // EGL spec says:
1002 // "surface must be bound to the calling thread's current context,
1003 // for the current rendering API."
1004 DisplayDevice::makeCurrent(mEGLDisplay,
1005 getDefaultDisplayDevice(), mEGLContext);
1006 }
Mathias Agopiane60b0682012-08-21 23:34:09 -07001007 hwc.commit();
Mathias Agopian52bbb1a2012-07-31 19:01:53 -07001008 }
1009
Mathias Agopian92a979a2012-08-02 18:32:23 -07001010 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
Mathias Agopian42977342012-08-05 00:40:46 -07001011 sp<const DisplayDevice> hw(mDisplays[dpy]);
Mathias Agopian13127d82013-03-05 17:47:11 -08001012 const Vector< sp<Layer> >& currentLayers(hw->getVisibleLayersSortedByZ());
Mathias Agopianda27af92012-09-13 18:17:13 -07001013 hw->onSwapBuffersCompleted(hwc);
Mathias Agopian52bbb1a2012-07-31 19:01:53 -07001014 const size_t count = currentLayers.size();
Mathias Agopiane60b0682012-08-21 23:34:09 -07001015 int32_t id = hw->getHwcDisplayId();
1016 if (id >=0 && hwc.initCheck() == NO_ERROR) {
Mathias Agopian1e260872012-08-08 18:35:12 -07001017 HWComposer::LayerListIterator cur = hwc.begin(id);
1018 const HWComposer::LayerListIterator end = hwc.end(id);
Mathias Agopian52bbb1a2012-07-31 19:01:53 -07001019 for (size_t i = 0; cur != end && i < count; ++i, ++cur) {
Mathias Agopiand3ee2312012-08-02 14:01:42 -07001020 currentLayers[i]->onLayerDisplayed(hw, &*cur);
Mathias Agopian52bbb1a2012-07-31 19:01:53 -07001021 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07001022 } else {
Mathias Agopian52bbb1a2012-07-31 19:01:53 -07001023 for (size_t i = 0; i < count; i++) {
Mathias Agopiand3ee2312012-08-02 14:01:42 -07001024 currentLayers[i]->onLayerDisplayed(hw, NULL);
Mathias Agopian52bbb1a2012-07-31 19:01:53 -07001025 }
Jesse Hallef194142012-06-14 14:45:17 -07001026 }
Jamie Gennise8696a42012-01-15 18:54:57 -08001027 }
1028
Mathias Agopiana44b0412011-10-16 18:46:35 -07001029 mLastSwapBufferTime = systemTime() - now;
1030 mDebugInSwapBuffers = 0;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001031}
1032
Mathias Agopian87baae12012-07-31 12:38:26 -07001033void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001034{
Mathias Agopian841cde52012-03-01 15:44:37 -08001035 ATRACE_CALL();
1036
Mathias Agopianca4d3602011-05-19 15:38:14 -07001037 Mutex::Autolock _l(mStateLock);
1038 const nsecs_t now = systemTime();
1039 mDebugInTransaction = now;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001040
Mathias Agopianca4d3602011-05-19 15:38:14 -07001041 // Here we're guaranteed that some transaction flags are set
1042 // so we can call handleTransactionLocked() unconditionally.
1043 // We call getTransactionFlags(), which will also clear the flags,
1044 // with mStateLock held to guarantee that mCurrentState won't change
1045 // until the transaction is committed.
Mathias Agopian4da75192010-08-10 17:19:56 -07001046
Mathias Agopiane57f2922012-08-09 16:29:12 -07001047 transactionFlags = getTransactionFlags(eTransactionMask);
Mathias Agopian87baae12012-07-31 12:38:26 -07001048 handleTransactionLocked(transactionFlags);
Mathias Agopiandea20b12011-05-03 17:04:02 -07001049
Mathias Agopianca4d3602011-05-19 15:38:14 -07001050 mLastTransactionTime = systemTime() - now;
1051 mDebugInTransaction = 0;
1052 invalidateHwcGeometry();
1053 // here the transaction has been committed
Mathias Agopian3d579642009-06-04 18:46:21 -07001054}
1055
Mathias Agopian87baae12012-07-31 12:38:26 -07001056void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
Mathias Agopian3d579642009-06-04 18:46:21 -07001057{
1058 const LayerVector& currentLayers(mCurrentState.layersSortedByZ);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001059 const size_t count = currentLayers.size();
1060
1061 /*
1062 * Traversal of the children
1063 * (perform the transaction for each of them if needed)
1064 */
1065
Mathias Agopian3559b072012-08-15 13:46:03 -07001066 if (transactionFlags & eTraversalNeeded) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001067 for (size_t i=0 ; i<count ; i++) {
Mathias Agopian13127d82013-03-05 17:47:11 -08001068 const sp<Layer>& layer(currentLayers[i]);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001069 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
1070 if (!trFlags) continue;
1071
1072 const uint32_t flags = layer->doTransaction(0);
1073 if (flags & Layer::eVisibleRegion)
1074 mVisibleRegionsDirty = true;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001075 }
1076 }
1077
1078 /*
Mathias Agopian3559b072012-08-15 13:46:03 -07001079 * Perform display own transactions if needed
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001080 */
1081
Mathias Agopiane57f2922012-08-09 16:29:12 -07001082 if (transactionFlags & eDisplayTransactionNeeded) {
Mathias Agopian92a979a2012-08-02 18:32:23 -07001083 // here we take advantage of Vector's copy-on-write semantics to
1084 // improve performance by skipping the transaction entirely when
1085 // know that the lists are identical
Mathias Agopiane57f2922012-08-09 16:29:12 -07001086 const KeyedVector< wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
1087 const KeyedVector< wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);
Mathias Agopian92a979a2012-08-02 18:32:23 -07001088 if (!curr.isIdenticalTo(draw)) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001089 mVisibleRegionsDirty = true;
Mathias Agopian92a979a2012-08-02 18:32:23 -07001090 const size_t cc = curr.size();
Mathias Agopian93997a82012-08-29 17:30:36 -07001091 size_t dc = draw.size();
Mathias Agopian92a979a2012-08-02 18:32:23 -07001092
1093 // find the displays that were removed
1094 // (ie: in drawing state but not in current state)
1095 // also handle displays that changed
1096 // (ie: displays that are in both lists)
1097 for (size_t i=0 ; i<dc ; i++) {
Mathias Agopiane57f2922012-08-09 16:29:12 -07001098 const ssize_t j = curr.indexOfKey(draw.keyAt(i));
1099 if (j < 0) {
Mathias Agopian92a979a2012-08-02 18:32:23 -07001100 // in drawing state but not in current state
Mathias Agopian3ee454a2012-08-27 16:28:24 -07001101 if (!draw[i].isMainDisplay()) {
Andy McFadden27ec5732012-10-02 19:04:45 -07001102 // Call makeCurrent() on the primary display so we can
1103 // be sure that nothing associated with this display
1104 // is current.
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07001105 const sp<const DisplayDevice> hw(getDefaultDisplayDevice());
Andy McFadden27ec5732012-10-02 19:04:45 -07001106 DisplayDevice::makeCurrent(mEGLDisplay, hw, mEGLContext);
Mathias Agopian3ee454a2012-08-27 16:28:24 -07001107 mDisplays.removeItem(draw.keyAt(i));
Andy McFadden27ec5732012-10-02 19:04:45 -07001108 getHwComposer().disconnectDisplay(draw[i].type);
Jesse Hall7adb0f82013-03-06 16:13:49 -08001109 if (draw[i].type < DisplayDevice::NUM_DISPLAY_TYPES)
1110 mEventThread->onHotplugReceived(draw[i].type, false);
Mathias Agopian92a979a2012-08-02 18:32:23 -07001111 } else {
1112 ALOGW("trying to remove the main display");
1113 }
1114 } else {
1115 // this display is in both lists. see if something changed.
Mathias Agopiane57f2922012-08-09 16:29:12 -07001116 const DisplayDeviceState& state(curr[j]);
Mathias Agopian3ee454a2012-08-27 16:28:24 -07001117 const wp<IBinder>& display(curr.keyAt(j));
Mathias Agopian111b2d82012-08-16 20:52:17 -07001118 if (state.surface->asBinder() != draw[i].surface->asBinder()) {
Mathias Agopiane57f2922012-08-09 16:29:12 -07001119 // changing the surface is like destroying and
Mathias Agopian93997a82012-08-29 17:30:36 -07001120 // recreating the DisplayDevice, so we just remove it
1121 // from the drawing state, so that it get re-added
1122 // below.
1123 mDisplays.removeItem(display);
1124 mDrawingState.displays.removeItemsAt(i);
1125 dc--; i--;
1126 // at this point we must loop to the next item
1127 continue;
1128 }
Mathias Agopiane57f2922012-08-09 16:29:12 -07001129
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07001130 const sp<DisplayDevice> disp(getDisplayDevice(display));
Mathias Agopian93997a82012-08-29 17:30:36 -07001131 if (disp != NULL) {
1132 if (state.layerStack != draw[i].layerStack) {
1133 disp->setLayerStack(state.layerStack);
1134 }
Mathias Agopian00e8c7a2012-09-04 19:30:46 -07001135 if ((state.orientation != draw[i].orientation)
1136 || (state.viewport != draw[i].viewport)
1137 || (state.frame != draw[i].frame))
1138 {
1139 disp->setProjection(state.orientation,
Jeff Brown4fb39992012-09-07 12:55:10 -07001140 state.viewport, state.frame);
Mathias Agopian93997a82012-08-29 17:30:36 -07001141 }
Mathias Agopian92a979a2012-08-02 18:32:23 -07001142 }
1143 }
1144 }
1145
1146 // find displays that were added
1147 // (ie: in current state but not in drawing state)
1148 for (size_t i=0 ; i<cc ; i++) {
Mathias Agopiane57f2922012-08-09 16:29:12 -07001149 if (draw.indexOfKey(curr.keyAt(i)) < 0) {
Mathias Agopiane57f2922012-08-09 16:29:12 -07001150 const DisplayDeviceState& state(curr[i]);
Mathias Agopiancde87a32012-09-13 14:09:01 -07001151
Jesse Hall99c7dbb2013-03-14 14:29:29 -07001152 sp<DisplaySurface> dispSurface;
Jesse Hallffe1f192013-03-22 15:13:48 -07001153 int32_t hwcDisplayId = allocateHwcDisplayId(state.type);
Jesse Hall99c7dbb2013-03-14 14:29:29 -07001154 if (state.isVirtualDisplay()) {
1155 if (state.surface != NULL) {
1156 dispSurface = new VirtualDisplaySurface(
Jesse Hallffe1f192013-03-22 15:13:48 -07001157 *mHwc, hwcDisplayId, state.surface,
Jesse Hall99c7dbb2013-03-14 14:29:29 -07001158 state.displayName);
1159 }
1160 } else {
Mathias Agopiancde87a32012-09-13 14:09:01 -07001161 ALOGE_IF(state.surface!=NULL,
1162 "adding a supported display, but rendering "
1163 "surface is provided (%p), ignoring it",
1164 state.surface.get());
1165
1166 // for supported (by hwc) displays we provide our
1167 // own rendering surface
Jesse Hall99c7dbb2013-03-14 14:29:29 -07001168 dispSurface = new FramebufferSurface(*mHwc, state.type);
Mathias Agopiancde87a32012-09-13 14:09:01 -07001169 }
1170
1171 const wp<IBinder>& display(curr.keyAt(i));
Jesse Hall99c7dbb2013-03-14 14:29:29 -07001172 if (dispSurface != NULL) {
Mathias Agopiancde87a32012-09-13 14:09:01 -07001173 sp<DisplayDevice> hw = new DisplayDevice(this,
Jesse Hallffe1f192013-03-22 15:13:48 -07001174 state.type, hwcDisplayId, state.isSecure,
1175 display, dispSurface, mEGLConfig);
Mathias Agopiancde87a32012-09-13 14:09:01 -07001176 hw->setLayerStack(state.layerStack);
1177 hw->setProjection(state.orientation,
Jeff Brown4fb39992012-09-07 12:55:10 -07001178 state.viewport, state.frame);
Andy McFadden8dfa92f2012-09-17 18:27:17 -07001179 hw->setDisplayName(state.displayName);
Mathias Agopiancde87a32012-09-13 14:09:01 -07001180 mDisplays.add(display, hw);
Jesse Hall7adb0f82013-03-06 16:13:49 -08001181 if (state.type < DisplayDevice::NUM_DISPLAY_TYPES)
1182 mEventThread->onHotplugReceived(state.type, true);
Mathias Agopian93997a82012-08-29 17:30:36 -07001183 }
Mathias Agopian92a979a2012-08-02 18:32:23 -07001184 }
1185 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001186 }
Mathias Agopian3559b072012-08-15 13:46:03 -07001187 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001188
Mathias Agopian84300952012-11-21 16:02:13 -08001189 if (transactionFlags & (eTraversalNeeded|eDisplayTransactionNeeded)) {
1190 // The transform hint might have changed for some layers
1191 // (either because a display has changed, or because a layer
1192 // as changed).
1193 //
1194 // Walk through all the layers in currentLayers,
1195 // and update their transform hint.
1196 //
1197 // If a layer is visible only on a single display, then that
1198 // display is used to calculate the hint, otherwise we use the
1199 // default display.
1200 //
1201 // NOTE: we do this here, rather than in rebuildLayerStacks() so that
1202 // the hint is set before we acquire a buffer from the surface texture.
1203 //
1204 // NOTE: layer transactions have taken place already, so we use their
1205 // drawing state. However, SurfaceFlinger's own transaction has not
1206 // happened yet, so we must use the current state layer list
1207 // (soon to become the drawing state list).
1208 //
1209 sp<const DisplayDevice> disp;
1210 uint32_t currentlayerStack = 0;
1211 for (size_t i=0; i<count; i++) {
1212 // NOTE: we rely on the fact that layers are sorted by
1213 // layerStack first (so we don't have to traverse the list
1214 // of displays for every layer).
Mathias Agopian13127d82013-03-05 17:47:11 -08001215 const sp<Layer>& layer(currentLayers[i]);
1216 uint32_t layerStack = layer->drawingState().layerStack;
Mathias Agopian84300952012-11-21 16:02:13 -08001217 if (i==0 || currentlayerStack != layerStack) {
1218 currentlayerStack = layerStack;
1219 // figure out if this layerstack is mirrored
1220 // (more than one display) if so, pick the default display,
1221 // if not, pick the only display it's on.
1222 disp.clear();
1223 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1224 sp<const DisplayDevice> hw(mDisplays[dpy]);
1225 if (hw->getLayerStack() == currentlayerStack) {
1226 if (disp == NULL) {
1227 disp = hw;
1228 } else {
1229 disp = getDefaultDisplayDevice();
1230 break;
1231 }
1232 }
1233 }
1234 }
1235 if (disp != NULL) {
1236 // presumably this means this layer is using a layerStack
1237 // that is not visible on any display
Mathias Agopian13127d82013-03-05 17:47:11 -08001238 layer->updateTransformHint(disp);
Mathias Agopian84300952012-11-21 16:02:13 -08001239 }
1240 }
1241 }
1242
1243
Mathias Agopian3559b072012-08-15 13:46:03 -07001244 /*
1245 * Perform our own transaction if needed
1246 */
Mathias Agopian0aa758d2009-04-22 15:23:34 -07001247
Mathias Agopiancd60f992012-08-16 16:28:27 -07001248 const LayerVector& previousLayers(mDrawingState.layersSortedByZ);
1249 if (currentLayers.size() > previousLayers.size()) {
Mathias Agopian3559b072012-08-15 13:46:03 -07001250 // layers have been added
1251 mVisibleRegionsDirty = true;
1252 }
1253
1254 // some layers might have been removed, so
1255 // we need to update the regions they're exposing.
1256 if (mLayersRemoved) {
1257 mLayersRemoved = false;
1258 mVisibleRegionsDirty = true;
Mathias Agopian3559b072012-08-15 13:46:03 -07001259 const size_t count = previousLayers.size();
1260 for (size_t i=0 ; i<count ; i++) {
Mathias Agopian13127d82013-03-05 17:47:11 -08001261 const sp<Layer>& layer(previousLayers[i]);
Mathias Agopian3559b072012-08-15 13:46:03 -07001262 if (currentLayers.indexOf(layer) < 0) {
1263 // this layer is not visible anymore
1264 // TODO: we could traverse the tree from front to back and
1265 // compute the actual visible region
1266 // TODO: we could cache the transformed region
Mathias Agopian1501d542012-09-04 21:04:09 -07001267 const Layer::State& s(layer->drawingState());
1268 Region visibleReg = s.transform.transform(
1269 Region(Rect(s.active.w, s.active.h)));
1270 invalidateLayerStack(s.layerStack, visibleReg);
Mathias Agopian0aa758d2009-04-22 15:23:34 -07001271 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001272 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001273 }
1274
1275 commitTransaction();
Mathias Agopian4fec8732012-06-29 14:12:52 -07001276}
1277
1278void SurfaceFlinger::commitTransaction()
1279{
1280 if (!mLayersPendingRemoval.isEmpty()) {
1281 // Notify removed layers now that they can't be drawn from
1282 for (size_t i = 0; i < mLayersPendingRemoval.size(); i++) {
1283 mLayersPendingRemoval[i]->onRemoved();
1284 }
1285 mLayersPendingRemoval.clear();
1286 }
1287
Jamie Gennis4b0eba92013-02-05 13:30:24 -08001288 // If this transaction is part of a window animation then the next frame
1289 // we composite should be considered an animation as well.
1290 mAnimCompositionPending = mAnimTransactionPending;
1291
Mathias Agopian4fec8732012-06-29 14:12:52 -07001292 mDrawingState = mCurrentState;
Jamie Gennis2d5e2302012-10-15 18:24:43 -07001293 mTransactionPending = false;
1294 mAnimTransactionPending = false;
Mathias Agopian4fec8732012-06-29 14:12:52 -07001295 mTransactionCV.broadcast();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001296}
1297
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001298void SurfaceFlinger::computeVisibleRegions(
Mathias Agopian87baae12012-07-31 12:38:26 -07001299 const LayerVector& currentLayers, uint32_t layerStack,
1300 Region& outDirtyRegion, Region& outOpaqueRegion)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001301{
Mathias Agopian841cde52012-03-01 15:44:37 -08001302 ATRACE_CALL();
1303
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001304 Region aboveOpaqueLayers;
1305 Region aboveCoveredLayers;
1306 Region dirty;
1307
Mathias Agopian87baae12012-07-31 12:38:26 -07001308 outDirtyRegion.clear();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001309
1310 size_t i = currentLayers.size();
1311 while (i--) {
Mathias Agopian13127d82013-03-05 17:47:11 -08001312 const sp<Layer>& layer = currentLayers[i];
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001313
1314 // start with the whole surface at its current location
Mathias Agopian97011222009-07-28 10:57:27 -07001315 const Layer::State& s(layer->drawingState());
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001316
Jesse Hall01e29052013-02-19 16:13:35 -08001317 // only consider the layers on the given layer stack
Mathias Agopian87baae12012-07-31 12:38:26 -07001318 if (s.layerStack != layerStack)
1319 continue;
1320
Mathias Agopianab028732010-03-16 16:41:46 -07001321 /*
1322 * opaqueRegion: area of a surface that is fully opaque.
1323 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001324 Region opaqueRegion;
Mathias Agopianab028732010-03-16 16:41:46 -07001325
1326 /*
1327 * visibleRegion: area of a surface that is visible on screen
1328 * and not fully transparent. This is essentially the layer's
1329 * footprint minus the opaque regions above it.
1330 * Areas covered by a translucent surface are considered visible.
1331 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001332 Region visibleRegion;
Mathias Agopianab028732010-03-16 16:41:46 -07001333
1334 /*
1335 * coveredRegion: area of a surface that is covered by all
1336 * visible regions above it (which includes the translucent areas).
1337 */
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001338 Region coveredRegion;
Mathias Agopianab028732010-03-16 16:41:46 -07001339
Jesse Halla8026d22012-09-25 13:25:04 -07001340 /*
1341 * transparentRegion: area of a surface that is hinted to be completely
1342 * transparent. This is only used to tell when the layer has no visible
1343 * non-transparent regions and can be removed from the layer list. It
1344 * does not affect the visibleRegion of this layer or any layers
1345 * beneath it. The hint may not be correct if apps don't respect the
1346 * SurfaceView restrictions (which, sadly, some don't).
1347 */
1348 Region transparentRegion;
1349
Mathias Agopianab028732010-03-16 16:41:46 -07001350
1351 // handle hidden surfaces by setting the visible region to empty
Mathias Agopianda27af92012-09-13 18:17:13 -07001352 if (CC_LIKELY(layer->isVisible())) {
Mathias Agopiana67932f2011-04-20 14:20:59 -07001353 const bool translucent = !layer->isOpaque();
Mathias Agopian5219a062013-02-26 16:37:53 -08001354 Rect bounds(s.transform.transform(layer->computeBounds()));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001355 visibleRegion.set(bounds);
Mathias Agopianab028732010-03-16 16:41:46 -07001356 if (!visibleRegion.isEmpty()) {
1357 // Remove the transparent area from the visible region
1358 if (translucent) {
Mathias Agopian4fec8732012-06-29 14:12:52 -07001359 const Transform tr(s.transform);
1360 if (tr.transformed()) {
1361 if (tr.preserveRects()) {
1362 // transform the transparent region
Mathias Agopian2ca79392013-04-02 18:30:32 -07001363 transparentRegion = tr.transform(s.activeTransparentRegion);
Mathias Agopian4fec8732012-06-29 14:12:52 -07001364 } else {
1365 // transformation too complex, can't do the
1366 // transparent region optimization.
Jesse Halla8026d22012-09-25 13:25:04 -07001367 transparentRegion.clear();
Mathias Agopian4fec8732012-06-29 14:12:52 -07001368 }
1369 } else {
Mathias Agopian2ca79392013-04-02 18:30:32 -07001370 transparentRegion = s.activeTransparentRegion;
Mathias Agopian4fec8732012-06-29 14:12:52 -07001371 }
Mathias Agopianab028732010-03-16 16:41:46 -07001372 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001373
Mathias Agopianab028732010-03-16 16:41:46 -07001374 // compute the opaque region
Mathias Agopian4fec8732012-06-29 14:12:52 -07001375 const int32_t layerOrientation = s.transform.getOrientation();
Mathias Agopianab028732010-03-16 16:41:46 -07001376 if (s.alpha==255 && !translucent &&
1377 ((layerOrientation & Transform::ROT_INVALID) == false)) {
1378 // the opaque region is the layer's footprint
1379 opaqueRegion = visibleRegion;
1380 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001381 }
1382 }
1383
Mathias Agopianab028732010-03-16 16:41:46 -07001384 // Clip the covered region to the visible region
1385 coveredRegion = aboveCoveredLayers.intersect(visibleRegion);
1386
1387 // Update aboveCoveredLayers for next (lower) layer
1388 aboveCoveredLayers.orSelf(visibleRegion);
1389
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001390 // subtract the opaque region covered by the layers above us
1391 visibleRegion.subtractSelf(aboveOpaqueLayers);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001392
1393 // compute this layer's dirty region
1394 if (layer->contentDirty) {
1395 // we need to invalidate the whole region
1396 dirty = visibleRegion;
1397 // as well, as the old visible region
Mathias Agopian4fec8732012-06-29 14:12:52 -07001398 dirty.orSelf(layer->visibleRegion);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001399 layer->contentDirty = false;
1400 } else {
Mathias Agopiana8d44f72009-06-28 02:54:16 -07001401 /* compute the exposed region:
Mathias Agopianab028732010-03-16 16:41:46 -07001402 * the exposed region consists of two components:
1403 * 1) what's VISIBLE now and was COVERED before
1404 * 2) what's EXPOSED now less what was EXPOSED before
1405 *
1406 * note that (1) is conservative, we start with the whole
1407 * visible region but only keep what used to be covered by
1408 * something -- which mean it may have been exposed.
1409 *
1410 * (2) handles areas that were not covered by anything but got
1411 * exposed because of a resize.
Mathias Agopiana8d44f72009-06-28 02:54:16 -07001412 */
Mathias Agopianab028732010-03-16 16:41:46 -07001413 const Region newExposed = visibleRegion - coveredRegion;
Mathias Agopian4fec8732012-06-29 14:12:52 -07001414 const Region oldVisibleRegion = layer->visibleRegion;
1415 const Region oldCoveredRegion = layer->coveredRegion;
Mathias Agopianab028732010-03-16 16:41:46 -07001416 const Region oldExposed = oldVisibleRegion - oldCoveredRegion;
1417 dirty = (visibleRegion&oldCoveredRegion) | (newExposed-oldExposed);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001418 }
1419 dirty.subtractSelf(aboveOpaqueLayers);
1420
1421 // accumulate to the screen dirty region
Mathias Agopian87baae12012-07-31 12:38:26 -07001422 outDirtyRegion.orSelf(dirty);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001423
Mathias Agopianab028732010-03-16 16:41:46 -07001424 // Update aboveOpaqueLayers for next (lower) layer
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001425 aboveOpaqueLayers.orSelf(opaqueRegion);
Andreas Huber8b42e8a2010-08-16 08:49:37 -07001426
Jesse Halla8026d22012-09-25 13:25:04 -07001427 // Store the visible region in screen space
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001428 layer->setVisibleRegion(visibleRegion);
1429 layer->setCoveredRegion(coveredRegion);
Jesse Halla8026d22012-09-25 13:25:04 -07001430 layer->setVisibleNonTransparentRegion(
1431 visibleRegion.subtract(transparentRegion));
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001432 }
1433
Mathias Agopian87baae12012-07-31 12:38:26 -07001434 outOpaqueRegion = aboveOpaqueLayers;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001435}
1436
Mathias Agopian87baae12012-07-31 12:38:26 -07001437void SurfaceFlinger::invalidateLayerStack(uint32_t layerStack,
1438 const Region& dirty) {
Mathias Agopian92a979a2012-08-02 18:32:23 -07001439 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
Mathias Agopian42977342012-08-05 00:40:46 -07001440 const sp<DisplayDevice>& hw(mDisplays[dpy]);
1441 if (hw->getLayerStack() == layerStack) {
1442 hw->dirtyRegion.orSelf(dirty);
Mathias Agopian92a979a2012-08-02 18:32:23 -07001443 }
1444 }
Mathias Agopian87baae12012-07-31 12:38:26 -07001445}
1446
1447void SurfaceFlinger::handlePageFlip()
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001448{
Mathias Agopian4fec8732012-06-29 14:12:52 -07001449 Region dirtyRegion;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001450
Mathias Agopian4fec8732012-06-29 14:12:52 -07001451 bool visibleRegions = false;
Mathias Agopiancd60f992012-08-16 16:28:27 -07001452 const LayerVector& currentLayers(mDrawingState.layersSortedByZ);
Mathias Agopian4fec8732012-06-29 14:12:52 -07001453 const size_t count = currentLayers.size();
Mathias Agopian4fec8732012-06-29 14:12:52 -07001454 for (size_t i=0 ; i<count ; i++) {
Mathias Agopian13127d82013-03-05 17:47:11 -08001455 const sp<Layer>& layer(currentLayers[i]);
Mathias Agopian87baae12012-07-31 12:38:26 -07001456 const Region dirty(layer->latchBuffer(visibleRegions));
Mathias Agopian1501d542012-09-04 21:04:09 -07001457 const Layer::State& s(layer->drawingState());
Mathias Agopian87baae12012-07-31 12:38:26 -07001458 invalidateLayerStack(s.layerStack, dirty);
Mathias Agopian4fec8732012-06-29 14:12:52 -07001459 }
Mathias Agopian4da75192010-08-10 17:19:56 -07001460
Mathias Agopian3b1d2b62012-07-11 13:48:17 -07001461 mVisibleRegionsDirty |= visibleRegions;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001462}
1463
Mathias Agopianad456f92011-01-13 17:53:01 -08001464void SurfaceFlinger::invalidateHwcGeometry()
1465{
1466 mHwWorkListDirty = true;
1467}
1468
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001469
Mathias Agopiancd60f992012-08-16 16:28:27 -07001470void SurfaceFlinger::doDisplayComposition(const sp<const DisplayDevice>& hw,
Mathias Agopian87baae12012-07-31 12:38:26 -07001471 const Region& inDirtyRegion)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001472{
Mathias Agopian87baae12012-07-31 12:38:26 -07001473 Region dirtyRegion(inDirtyRegion);
1474
Mathias Agopianb8a55602009-06-26 19:06:36 -07001475 // compute the invalid region
Mathias Agopian42977342012-08-05 00:40:46 -07001476 hw->swapRegion.orSelf(dirtyRegion);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001477
Mathias Agopian42977342012-08-05 00:40:46 -07001478 uint32_t flags = hw->getFlags();
Mathias Agopian0f2f5ff2012-07-31 23:09:07 -07001479 if (flags & DisplayDevice::SWAP_RECTANGLE) {
Mathias Agopian29d06ac2009-06-29 18:49:56 -07001480 // we can redraw only what's dirty, but since SWAP_RECTANGLE only
1481 // takes a rectangle, we must make sure to update that whole
1482 // rectangle in that case
Mathias Agopian42977342012-08-05 00:40:46 -07001483 dirtyRegion.set(hw->swapRegion.bounds());
Mathias Agopian29d06ac2009-06-29 18:49:56 -07001484 } else {
Mathias Agopian0f2f5ff2012-07-31 23:09:07 -07001485 if (flags & DisplayDevice::PARTIAL_UPDATES) {
Mathias Agopian29d06ac2009-06-29 18:49:56 -07001486 // We need to redraw the rectangle that will be updated
1487 // (pushed to the framebuffer).
Mathias Agopian95a666b2009-09-24 14:57:26 -07001488 // This is needed because PARTIAL_UPDATES only takes one
Mathias Agopian0f2f5ff2012-07-31 23:09:07 -07001489 // rectangle instead of a region (see DisplayDevice::flip())
Mathias Agopian42977342012-08-05 00:40:46 -07001490 dirtyRegion.set(hw->swapRegion.bounds());
Mathias Agopian29d06ac2009-06-29 18:49:56 -07001491 } else {
1492 // we need to redraw everything (the whole screen)
Mathias Agopian42977342012-08-05 00:40:46 -07001493 dirtyRegion.set(hw->bounds());
1494 hw->swapRegion = dirtyRegion;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001495 }
1496 }
1497
Mathias Agopiancd60f992012-08-16 16:28:27 -07001498 doComposeSurfaces(hw, dirtyRegion);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001499
Mathias Agopian9c6e2972011-09-20 17:21:56 -07001500 // update the swap region and clear the dirty region
Mathias Agopian42977342012-08-05 00:40:46 -07001501 hw->swapRegion.orSelf(dirtyRegion);
Mathias Agopianda27af92012-09-13 18:17:13 -07001502
1503 // swap buffers (presentation)
1504 hw->swapBuffers(getHwComposer());
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001505}
1506
Mathias Agopiancd60f992012-08-16 16:28:27 -07001507void SurfaceFlinger::doComposeSurfaces(const sp<const DisplayDevice>& hw, const Region& dirty)
Mathias Agopianf384cc32011-09-08 18:31:55 -07001508{
Mathias Agopian85d751c2012-08-29 16:59:24 -07001509 const int32_t id = hw->getHwcDisplayId();
Mathias Agopian86303202012-07-24 22:46:10 -07001510 HWComposer& hwc(getHwComposer());
Mathias Agopian1e260872012-08-08 18:35:12 -07001511 HWComposer::LayerListIterator cur = hwc.begin(id);
1512 const HWComposer::LayerListIterator end = hwc.end(id);
Mathias Agopiancd20eb02011-09-22 20:57:04 -07001513
Mathias Agopian85d751c2012-08-29 16:59:24 -07001514 const bool hasGlesComposition = hwc.hasGlesComposition(id) || (cur==end);
1515 if (hasGlesComposition) {
Mathias Agopianda8d0a52012-09-04 15:05:38 -07001516 DisplayDevice::makeCurrent(mEGLDisplay, hw, mEGLContext);
Mathias Agopian52bbb1a2012-07-31 19:01:53 -07001517
1518 // set the frame buffer
1519 glMatrixMode(GL_MODELVIEW);
1520 glLoadIdentity();
1521
1522 // Never touch the framebuffer if we don't have any framebuffer layers
Mathias Agopian85d751c2012-08-29 16:59:24 -07001523 const bool hasHwcComposition = hwc.hasHwcComposition(id);
Mathias Agopiane60b0682012-08-21 23:34:09 -07001524 if (hasHwcComposition) {
Mathias Agopianb9494d52012-04-18 02:28:45 -07001525 // when using overlays, we assume a fully transparent framebuffer
1526 // NOTE: we could reduce how much we need to clear, for instance
1527 // remove where there are opaque FB layers. however, on some
1528 // GPUs doing a "clean slate" glClear might be more efficient.
1529 // We'll revisit later if needed.
1530 glClearColor(0, 0, 0, 0);
1531 glClear(GL_COLOR_BUFFER_BIT);
1532 } else {
Mathias Agopian766dc492012-10-30 18:08:06 -07001533 // we start with the whole screen area
1534 const Region bounds(hw->getBounds());
1535
1536 // we remove the scissor part
1537 // we're left with the letterbox region
1538 // (common case is that letterbox ends-up being empty)
1539 const Region letterbox(bounds.subtract(hw->getScissor()));
1540
1541 // compute the area to clear
1542 Region region(hw->undefinedRegion.merge(letterbox));
1543
1544 // but limit it to the dirty region
1545 region.andSelf(dirty);
1546
Mathias Agopianb9494d52012-04-18 02:28:45 -07001547 // screen is already cleared here
Mathias Agopian87baae12012-07-31 12:38:26 -07001548 if (!region.isEmpty()) {
Mathias Agopianb9494d52012-04-18 02:28:45 -07001549 // can happen with SurfaceView
Mathias Agopian55801e42012-08-27 18:54:24 -07001550 drawWormhole(hw, region);
Mathias Agopianb9494d52012-04-18 02:28:45 -07001551 }
Mathias Agopiana2f4e562012-04-15 23:34:59 -07001552 }
Mathias Agopianf45c5102012-10-24 16:29:17 -07001553
Mathias Agopian766dc492012-10-30 18:08:06 -07001554 if (hw->getDisplayType() != DisplayDevice::DISPLAY_PRIMARY) {
1555 // just to be on the safe side, we don't set the
Mathias Agopianf45c5102012-10-24 16:29:17 -07001556 // scissor on the main display. It should never be needed
1557 // anyways (though in theory it could since the API allows it).
1558 const Rect& bounds(hw->getBounds());
Mathias Agopian766dc492012-10-30 18:08:06 -07001559 const Rect& scissor(hw->getScissor());
Mathias Agopianf45c5102012-10-24 16:29:17 -07001560 if (scissor != bounds) {
1561 // scissor doesn't match the screen's dimensions, so we
1562 // need to clear everything outside of it and enable
1563 // the GL scissor so we don't draw anything where we shouldn't
1564 const GLint height = hw->getHeight();
1565 glScissor(scissor.left, height - scissor.bottom,
1566 scissor.getWidth(), scissor.getHeight());
Mathias Agopianf45c5102012-10-24 16:29:17 -07001567 // enable scissor for this frame
1568 glEnable(GL_SCISSOR_TEST);
1569 }
1570 }
Mathias Agopian85d751c2012-08-29 16:59:24 -07001571 }
Mathias Agopian4b2ba532012-03-29 12:23:51 -07001572
Mathias Agopian85d751c2012-08-29 16:59:24 -07001573 /*
1574 * and then, render the layers targeted at the framebuffer
1575 */
Mathias Agopian4b2ba532012-03-29 12:23:51 -07001576
Mathias Agopian13127d82013-03-05 17:47:11 -08001577 const Vector< sp<Layer> >& layers(hw->getVisibleLayersSortedByZ());
Mathias Agopian85d751c2012-08-29 16:59:24 -07001578 const size_t count = layers.size();
1579 const Transform& tr = hw->getTransform();
1580 if (cur != end) {
1581 // we're using h/w composer
1582 for (size_t i=0 ; i<count && cur!=end ; ++i, ++cur) {
Mathias Agopian13127d82013-03-05 17:47:11 -08001583 const sp<Layer>& layer(layers[i]);
Mathias Agopian4fec8732012-06-29 14:12:52 -07001584 const Region clip(dirty.intersect(tr.transform(layer->visibleRegion)));
Mathias Agopian85d751c2012-08-29 16:59:24 -07001585 if (!clip.isEmpty()) {
1586 switch (cur->getCompositionType()) {
1587 case HWC_OVERLAY: {
1588 if ((cur->getHints() & HWC_HINT_CLEAR_FB)
1589 && i
1590 && layer->isOpaque()
1591 && hasGlesComposition) {
Mathias Agopiancd60f992012-08-16 16:28:27 -07001592 // never clear the very first layer since we're
1593 // guaranteed the FB is already cleared
1594 layer->clearWithOpenGL(hw, clip);
1595 }
Mathias Agopian85d751c2012-08-29 16:59:24 -07001596 break;
Mathias Agopiancd60f992012-08-16 16:28:27 -07001597 }
Mathias Agopian85d751c2012-08-29 16:59:24 -07001598 case HWC_FRAMEBUFFER: {
1599 layer->draw(hw, clip);
1600 break;
1601 }
Mathias Agopianda27af92012-09-13 18:17:13 -07001602 case HWC_FRAMEBUFFER_TARGET: {
1603 // this should not happen as the iterator shouldn't
1604 // let us get there.
1605 ALOGW("HWC_FRAMEBUFFER_TARGET found in hwc list (index=%d)", i);
1606 break;
1607 }
Mathias Agopiancd60f992012-08-16 16:28:27 -07001608 }
Mathias Agopian85d751c2012-08-29 16:59:24 -07001609 }
1610 layer->setAcquireFence(hw, *cur);
1611 }
1612 } else {
1613 // we're not using h/w composer
1614 for (size_t i=0 ; i<count ; ++i) {
Mathias Agopian13127d82013-03-05 17:47:11 -08001615 const sp<Layer>& layer(layers[i]);
Mathias Agopian85d751c2012-08-29 16:59:24 -07001616 const Region clip(dirty.intersect(
1617 tr.transform(layer->visibleRegion)));
1618 if (!clip.isEmpty()) {
1619 layer->draw(hw, clip);
Jesse Halla6b32db2012-07-19 16:44:38 -07001620 }
Mathias Agopian4b2ba532012-03-29 12:23:51 -07001621 }
1622 }
Mathias Agopianf45c5102012-10-24 16:29:17 -07001623
1624 // disable scissor at the end of the frame
1625 glDisable(GL_SCISSOR_TEST);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001626}
1627
Mathias Agopian55801e42012-08-27 18:54:24 -07001628void SurfaceFlinger::drawWormhole(const sp<const DisplayDevice>& hw,
1629 const Region& region) const
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001630{
Mathias Agopianf74e8e02012-04-16 03:14:05 -07001631 glDisable(GL_TEXTURE_EXTERNAL_OES);
Mathias Agopianb9494d52012-04-18 02:28:45 -07001632 glDisable(GL_TEXTURE_2D);
Mathias Agopianf74e8e02012-04-16 03:14:05 -07001633 glDisable(GL_BLEND);
Mathias Agopianb9494d52012-04-18 02:28:45 -07001634 glColor4f(0,0,0,0);
Mathias Agopianf74e8e02012-04-16 03:14:05 -07001635
Mathias Agopian55801e42012-08-27 18:54:24 -07001636 const int32_t height = hw->getHeight();
Mathias Agopianf74e8e02012-04-16 03:14:05 -07001637 Region::const_iterator it = region.begin();
1638 Region::const_iterator const end = region.end();
1639 while (it != end) {
1640 const Rect& r = *it++;
Mathias Agopian55801e42012-08-27 18:54:24 -07001641 GLfloat vertices[][2] = {
Andy McFadden8f06a8c2013-01-11 10:24:34 -08001642 { (GLfloat) r.left, (GLfloat) (height - r.top) },
1643 { (GLfloat) r.left, (GLfloat) (height - r.bottom) },
1644 { (GLfloat) r.right, (GLfloat) (height - r.bottom) },
1645 { (GLfloat) r.right, (GLfloat) (height - r.top) }
Mathias Agopian55801e42012-08-27 18:54:24 -07001646 };
1647 glVertexPointer(2, GL_FLOAT, 0, vertices);
Mathias Agopianf74e8e02012-04-16 03:14:05 -07001648 glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1649 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001650}
1651
Mathias Agopianac9fa422013-02-11 16:40:36 -08001652void SurfaceFlinger::addClientLayer(const sp<Client>& client,
1653 const sp<IBinder>& handle,
Mathias Agopian67106042013-03-14 19:18:13 -07001654 const sp<IGraphicBufferProducer>& gbc,
Mathias Agopian13127d82013-03-05 17:47:11 -08001655 const sp<Layer>& lbc)
Mathias Agopian96f08192010-06-02 23:28:45 -07001656{
Mathias Agopian96f08192010-06-02 23:28:45 -07001657 // attach this layer to the client
Mathias Agopianac9fa422013-02-11 16:40:36 -08001658 client->attachLayer(handle, lbc);
Mathias Agopian4f113742011-05-03 16:21:41 -07001659
Mathias Agopian96f08192010-06-02 23:28:45 -07001660 // add this layer to the current state list
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001661 Mutex::Autolock _l(mStateLock);
1662 mCurrentState.layersSortedByZ.add(lbc);
Mathias Agopian67106042013-03-14 19:18:13 -07001663 mGraphicBufferProducerList.add(gbc->asBinder());
Mathias Agopian96f08192010-06-02 23:28:45 -07001664}
1665
Mathias Agopian13127d82013-03-05 17:47:11 -08001666status_t SurfaceFlinger::removeLayer(const sp<Layer>& layer)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001667{
1668 Mutex::Autolock _l(mStateLock);
Mathias Agopian13127d82013-03-05 17:47:11 -08001669 ssize_t index = mCurrentState.layersSortedByZ.remove(layer);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001670 if (index >= 0) {
Mathias Agopian67106042013-03-14 19:18:13 -07001671 mLayersPendingRemoval.push(layer);
Mathias Agopian076b1cc2009-04-10 14:24:30 -07001672 mLayersRemoved = true;
Mathias Agopian67106042013-03-14 19:18:13 -07001673 setTransactionFlags(eTransactionNeeded);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001674 return NO_ERROR;
1675 }
Mathias Agopian3d579642009-06-04 18:46:21 -07001676 return status_t(index);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001677}
1678
Mathias Agopiandea20b12011-05-03 17:04:02 -07001679uint32_t SurfaceFlinger::peekTransactionFlags(uint32_t flags)
1680{
1681 return android_atomic_release_load(&mTransactionFlags);
1682}
1683
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001684uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags)
1685{
1686 return android_atomic_and(~flags, &mTransactionFlags) & flags;
1687}
1688
Mathias Agopianbb641242010-05-18 17:06:55 -07001689uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001690{
1691 uint32_t old = android_atomic_or(flags, &mTransactionFlags);
1692 if ((old & flags)==0) { // wake the server up
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08001693 signalTransaction();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001694 }
1695 return old;
1696}
1697
Mathias Agopian8b33f032012-07-24 20:43:54 -07001698void SurfaceFlinger::setTransactionState(
1699 const Vector<ComposerState>& state,
1700 const Vector<DisplayState>& displays,
1701 uint32_t flags)
1702{
Jamie Gennis7c41bf72012-10-17 09:29:47 -07001703 ATRACE_CALL();
Mathias Agopian698c0872011-06-28 19:09:31 -07001704 Mutex::Autolock _l(mStateLock);
Jamie Gennis28378392011-10-12 17:39:00 -07001705 uint32_t transactionFlags = 0;
Mathias Agopiane57f2922012-08-09 16:29:12 -07001706
Jamie Gennis2d5e2302012-10-15 18:24:43 -07001707 if (flags & eAnimation) {
1708 // For window updates that are part of an animation we must wait for
1709 // previous animation "frames" to be handled.
1710 while (mAnimTransactionPending) {
Jamie Gennis7c41bf72012-10-17 09:29:47 -07001711 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
Jamie Gennis2d5e2302012-10-15 18:24:43 -07001712 if (CC_UNLIKELY(err != NO_ERROR)) {
1713 // just in case something goes wrong in SF, return to the
Jamie Gennis7c41bf72012-10-17 09:29:47 -07001714 // caller after a few seconds.
1715 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out "
1716 "waiting for previous animation frame");
Jamie Gennis2d5e2302012-10-15 18:24:43 -07001717 mAnimTransactionPending = false;
1718 break;
1719 }
1720 }
1721 }
1722
Mathias Agopiane57f2922012-08-09 16:29:12 -07001723 size_t count = displays.size();
1724 for (size_t i=0 ; i<count ; i++) {
1725 const DisplayState& s(displays[i]);
1726 transactionFlags |= setDisplayStateLocked(s);
Jamie Gennisb8d69a52011-10-10 15:48:06 -07001727 }
1728
Mathias Agopiane57f2922012-08-09 16:29:12 -07001729 count = state.size();
Mathias Agopian698c0872011-06-28 19:09:31 -07001730 for (size_t i=0 ; i<count ; i++) {
1731 const ComposerState& s(state[i]);
Mathias Agopiand17e3b52012-10-22 14:27:45 -07001732 // Here we need to check that the interface we're given is indeed
1733 // one of our own. A malicious client could give us a NULL
1734 // IInterface, or one of its own or even one of our own but a
1735 // different type. All these situations would cause us to crash.
1736 //
1737 // NOTE: it would be better to use RTTI as we could directly check
1738 // that we have a Client*. however, RTTI is disabled in Android.
1739 if (s.client != NULL) {
1740 sp<IBinder> binder = s.client->asBinder();
1741 if (binder != NULL) {
1742 String16 desc(binder->getInterfaceDescriptor());
1743 if (desc == ISurfaceComposerClient::descriptor) {
1744 sp<Client> client( static_cast<Client *>(s.client.get()) );
1745 transactionFlags |= setClientStateLocked(client, s.state);
1746 }
1747 }
1748 }
Mathias Agopian698c0872011-06-28 19:09:31 -07001749 }
Mathias Agopian698c0872011-06-28 19:09:31 -07001750
Mathias Agopian386aa982011-11-07 21:58:03 -08001751 if (transactionFlags) {
1752 // this triggers the transaction
1753 setTransactionFlags(transactionFlags);
1754
1755 // if this is a synchronous transaction, wait for it to take effect
1756 // before returning.
1757 if (flags & eSynchronous) {
Jamie Gennis2d5e2302012-10-15 18:24:43 -07001758 mTransactionPending = true;
Mathias Agopian386aa982011-11-07 21:58:03 -08001759 }
Jamie Gennis2d5e2302012-10-15 18:24:43 -07001760 if (flags & eAnimation) {
1761 mAnimTransactionPending = true;
1762 }
1763 while (mTransactionPending) {
Mathias Agopian386aa982011-11-07 21:58:03 -08001764 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
1765 if (CC_UNLIKELY(err != NO_ERROR)) {
1766 // just in case something goes wrong in SF, return to the
1767 // called after a few seconds.
Jamie Gennis2d5e2302012-10-15 18:24:43 -07001768 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!");
1769 mTransactionPending = false;
Mathias Agopian386aa982011-11-07 21:58:03 -08001770 break;
1771 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -07001772 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001773 }
1774}
1775
Mathias Agopiane57f2922012-08-09 16:29:12 -07001776uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s)
1777{
Jesse Hall9a143922012-10-04 16:29:19 -07001778 ssize_t dpyIdx = mCurrentState.displays.indexOfKey(s.token);
1779 if (dpyIdx < 0)
1780 return 0;
1781
Mathias Agopiane57f2922012-08-09 16:29:12 -07001782 uint32_t flags = 0;
Jesse Hall9a143922012-10-04 16:29:19 -07001783 DisplayDeviceState& disp(mCurrentState.displays.editValueAt(dpyIdx));
Mathias Agopian3ee454a2012-08-27 16:28:24 -07001784 if (disp.isValid()) {
Mathias Agopiane57f2922012-08-09 16:29:12 -07001785 const uint32_t what = s.what;
1786 if (what & DisplayState::eSurfaceChanged) {
1787 if (disp.surface->asBinder() != s.surface->asBinder()) {
1788 disp.surface = s.surface;
1789 flags |= eDisplayTransactionNeeded;
1790 }
1791 }
1792 if (what & DisplayState::eLayerStackChanged) {
1793 if (disp.layerStack != s.layerStack) {
1794 disp.layerStack = s.layerStack;
1795 flags |= eDisplayTransactionNeeded;
1796 }
1797 }
Mathias Agopian00e8c7a2012-09-04 19:30:46 -07001798 if (what & DisplayState::eDisplayProjectionChanged) {
Mathias Agopiane57f2922012-08-09 16:29:12 -07001799 if (disp.orientation != s.orientation) {
1800 disp.orientation = s.orientation;
1801 flags |= eDisplayTransactionNeeded;
1802 }
1803 if (disp.frame != s.frame) {
1804 disp.frame = s.frame;
1805 flags |= eDisplayTransactionNeeded;
1806 }
1807 if (disp.viewport != s.viewport) {
1808 disp.viewport = s.viewport;
1809 flags |= eDisplayTransactionNeeded;
1810 }
1811 }
1812 }
1813 return flags;
1814}
1815
1816uint32_t SurfaceFlinger::setClientStateLocked(
1817 const sp<Client>& client,
1818 const layer_state_t& s)
1819{
1820 uint32_t flags = 0;
Mathias Agopian13127d82013-03-05 17:47:11 -08001821 sp<Layer> layer(client->getLayerUser(s.surface));
Mathias Agopiane57f2922012-08-09 16:29:12 -07001822 if (layer != 0) {
1823 const uint32_t what = s.what;
1824 if (what & layer_state_t::ePositionChanged) {
1825 if (layer->setPosition(s.x, s.y))
1826 flags |= eTraversalNeeded;
1827 }
1828 if (what & layer_state_t::eLayerChanged) {
1829 // NOTE: index needs to be calculated before we update the state
1830 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
1831 if (layer->setLayer(s.z)) {
1832 mCurrentState.layersSortedByZ.removeAt(idx);
1833 mCurrentState.layersSortedByZ.add(layer);
1834 // we need traversal (state changed)
1835 // AND transaction (list changed)
1836 flags |= eTransactionNeeded|eTraversalNeeded;
1837 }
1838 }
1839 if (what & layer_state_t::eSizeChanged) {
1840 if (layer->setSize(s.w, s.h)) {
1841 flags |= eTraversalNeeded;
1842 }
1843 }
1844 if (what & layer_state_t::eAlphaChanged) {
1845 if (layer->setAlpha(uint8_t(255.0f*s.alpha+0.5f)))
1846 flags |= eTraversalNeeded;
1847 }
1848 if (what & layer_state_t::eMatrixChanged) {
1849 if (layer->setMatrix(s.matrix))
1850 flags |= eTraversalNeeded;
1851 }
1852 if (what & layer_state_t::eTransparentRegionChanged) {
1853 if (layer->setTransparentRegionHint(s.transparentRegion))
1854 flags |= eTraversalNeeded;
1855 }
1856 if (what & layer_state_t::eVisibilityChanged) {
1857 if (layer->setFlags(s.flags, s.mask))
1858 flags |= eTraversalNeeded;
1859 }
1860 if (what & layer_state_t::eCropChanged) {
1861 if (layer->setCrop(s.crop))
1862 flags |= eTraversalNeeded;
1863 }
1864 if (what & layer_state_t::eLayerStackChanged) {
1865 // NOTE: index needs to be calculated before we update the state
1866 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
1867 if (layer->setLayerStack(s.layerStack)) {
1868 mCurrentState.layersSortedByZ.removeAt(idx);
1869 mCurrentState.layersSortedByZ.add(layer);
1870 // we need traversal (state changed)
1871 // AND transaction (list changed)
1872 flags |= eTransactionNeeded|eTraversalNeeded;
1873 }
1874 }
1875 }
1876 return flags;
1877}
1878
Mathias Agopian4d9b8222013-03-12 17:11:48 -07001879status_t SurfaceFlinger::createLayer(
Mathias Agopian0ef4e152011-04-20 14:19:32 -07001880 const String8& name,
1881 const sp<Client>& client,
Mathias Agopian4d9b8222013-03-12 17:11:48 -07001882 uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
1883 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001884{
Mathias Agopian4d9b8222013-03-12 17:11:48 -07001885 //ALOGD("createLayer for (%d x %d), name=%s", w, h, name.string());
Mathias Agopian6e2d6482009-07-09 18:16:43 -07001886 if (int32_t(w|h) < 0) {
Mathias Agopian921e6ac2012-07-23 23:11:29 -07001887 ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
Mathias Agopian6e2d6482009-07-09 18:16:43 -07001888 int(w), int(h));
Mathias Agopian4d9b8222013-03-12 17:11:48 -07001889 return BAD_VALUE;
Mathias Agopian6e2d6482009-07-09 18:16:43 -07001890 }
Andreas Huber8b42e8a2010-08-16 08:49:37 -07001891
Mathias Agopian4d9b8222013-03-12 17:11:48 -07001892 status_t result = NO_ERROR;
1893
1894 sp<Layer> layer;
1895
Mathias Agopian3165cc22012-08-08 19:42:09 -07001896 switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
1897 case ISurfaceComposerClient::eFXSurfaceNormal:
Mathias Agopian4d9b8222013-03-12 17:11:48 -07001898 result = createNormalLayer(client,
1899 name, w, h, flags, format,
1900 handle, gbp, &layer);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001901 break;
Mathias Agopian3165cc22012-08-08 19:42:09 -07001902 case ISurfaceComposerClient::eFXSurfaceDim:
Mathias Agopian4d9b8222013-03-12 17:11:48 -07001903 result = createDimLayer(client,
1904 name, w, h, flags,
1905 handle, gbp, &layer);
1906 break;
1907 default:
1908 result = BAD_VALUE;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001909 break;
1910 }
1911
Mathias Agopian4d9b8222013-03-12 17:11:48 -07001912 if (result == NO_ERROR) {
Mathias Agopian67106042013-03-14 19:18:13 -07001913 addClientLayer(client, *handle, *gbp, layer);
Mathias Agopian96f08192010-06-02 23:28:45 -07001914 setTransactionFlags(eTransactionNeeded);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001915 }
Mathias Agopian4d9b8222013-03-12 17:11:48 -07001916 return result;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001917}
1918
Mathias Agopian4d9b8222013-03-12 17:11:48 -07001919status_t SurfaceFlinger::createNormalLayer(const sp<Client>& client,
1920 const String8& name, uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
1921 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001922{
1923 // initialize the surfaces
Mathias Agopian92a979a2012-08-02 18:32:23 -07001924 switch (format) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001925 case PIXEL_FORMAT_TRANSPARENT:
1926 case PIXEL_FORMAT_TRANSLUCENT:
1927 format = PIXEL_FORMAT_RGBA_8888;
1928 break;
1929 case PIXEL_FORMAT_OPAQUE:
Mathias Agopiana8f3e4e2010-06-30 15:43:47 -07001930#ifdef NO_RGBX_8888
1931 format = PIXEL_FORMAT_RGB_565;
1932#else
Mathias Agopian8f105402010-04-05 18:01:24 -07001933 format = PIXEL_FORMAT_RGBX_8888;
Mathias Agopiana8f3e4e2010-06-30 15:43:47 -07001934#endif
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001935 break;
1936 }
1937
Mathias Agopiana8f3e4e2010-06-30 15:43:47 -07001938#ifdef NO_RGBX_8888
1939 if (format == PIXEL_FORMAT_RGBX_8888)
1940 format = PIXEL_FORMAT_RGBA_8888;
1941#endif
1942
Mathias Agopian4d9b8222013-03-12 17:11:48 -07001943 *outLayer = new Layer(this, client, name, w, h, flags);
1944 status_t err = (*outLayer)->setBuffers(w, h, format, flags);
1945 if (err == NO_ERROR) {
1946 *handle = (*outLayer)->getHandle();
1947 *gbp = (*outLayer)->getBufferQueue();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001948 }
Mathias Agopian4d9b8222013-03-12 17:11:48 -07001949
1950 ALOGE_IF(err, "createNormalLayer() failed (%s)", strerror(-err));
1951 return err;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001952}
1953
Mathias Agopian4d9b8222013-03-12 17:11:48 -07001954status_t SurfaceFlinger::createDimLayer(const sp<Client>& client,
1955 const String8& name, uint32_t w, uint32_t h, uint32_t flags,
1956 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001957{
Mathias Agopian4d9b8222013-03-12 17:11:48 -07001958 *outLayer = new LayerDim(this, client, name, w, h, flags);
1959 *handle = (*outLayer)->getHandle();
1960 *gbp = (*outLayer)->getBufferQueue();
1961 return NO_ERROR;
Mathias Agopian118d0242011-10-13 16:02:48 -07001962}
1963
Mathias Agopianac9fa422013-02-11 16:40:36 -08001964status_t SurfaceFlinger::onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001965{
Mathias Agopian67106042013-03-14 19:18:13 -07001966 // called by the window manager when it wants to remove a Layer
1967 status_t err = NO_ERROR;
1968 sp<Layer> l(client->getLayerUser(handle));
1969 if (l != NULL) {
1970 err = removeLayer(l);
1971 ALOGE_IF(err<0 && err != NAME_NOT_FOUND,
1972 "error removing layer=%p (%s)", l.get(), strerror(-err));
Mathias Agopian9a112062009-04-17 19:36:26 -07001973 }
1974 return err;
1975}
1976
Mathias Agopian13127d82013-03-05 17:47:11 -08001977status_t SurfaceFlinger::onLayerDestroyed(const wp<Layer>& layer)
Mathias Agopian9a112062009-04-17 19:36:26 -07001978{
Mathias Agopian67106042013-03-14 19:18:13 -07001979 // called by ~LayerCleaner() when all references to the IBinder (handle)
1980 // are gone
Mathias Agopianca4d3602011-05-19 15:38:14 -07001981 status_t err = NO_ERROR;
Mathias Agopian13127d82013-03-05 17:47:11 -08001982 sp<Layer> l(layer.promote());
Mathias Agopianca4d3602011-05-19 15:38:14 -07001983 if (l != NULL) {
Mathias Agopian67106042013-03-14 19:18:13 -07001984 err = removeLayer(l);
Steve Blocke6f43dd2012-01-06 19:20:56 +00001985 ALOGE_IF(err<0 && err != NAME_NOT_FOUND,
Mathias Agopianca4d3602011-05-19 15:38:14 -07001986 "error removing layer=%p (%s)", l.get(), strerror(-err));
1987 }
1988 return err;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001989}
1990
Mathias Agopianb60314a2012-04-10 22:09:54 -07001991// ---------------------------------------------------------------------------
1992
Andy McFadden13a082e2012-08-24 10:16:42 -07001993void SurfaceFlinger::onInitializeDisplays() {
Jesse Hall01e29052013-02-19 16:13:35 -08001994 // reset screen orientation and use primary layer stack
Andy McFadden13a082e2012-08-24 10:16:42 -07001995 Vector<ComposerState> state;
1996 Vector<DisplayState> displays;
1997 DisplayState d;
Jesse Hall01e29052013-02-19 16:13:35 -08001998 d.what = DisplayState::eDisplayProjectionChanged |
1999 DisplayState::eLayerStackChanged;
Jesse Hall692c7232012-11-08 15:41:56 -08002000 d.token = mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY];
Jesse Hall01e29052013-02-19 16:13:35 -08002001 d.layerStack = 0;
Andy McFadden13a082e2012-08-24 10:16:42 -07002002 d.orientation = DisplayState::eOrientationDefault;
Jeff Brown4c05dd12012-09-09 00:07:17 -07002003 d.frame.makeInvalid();
2004 d.viewport.makeInvalid();
Andy McFadden13a082e2012-08-24 10:16:42 -07002005 displays.add(d);
2006 setTransactionState(state, displays, 0);
Mathias Agopiancde87a32012-09-13 14:09:01 -07002007 onScreenAcquired(getDefaultDisplayDevice());
Andy McFadden13a082e2012-08-24 10:16:42 -07002008}
2009
2010void SurfaceFlinger::initializeDisplays() {
2011 class MessageScreenInitialized : public MessageBase {
2012 SurfaceFlinger* flinger;
2013 public:
2014 MessageScreenInitialized(SurfaceFlinger* flinger) : flinger(flinger) { }
2015 virtual bool handler() {
2016 flinger->onInitializeDisplays();
2017 return true;
2018 }
2019 };
2020 sp<MessageBase> msg = new MessageScreenInitialized(this);
2021 postMessageAsync(msg); // we may be called from main thread, use async message
2022}
2023
2024
Mathias Agopiancde87a32012-09-13 14:09:01 -07002025void SurfaceFlinger::onScreenAcquired(const sp<const DisplayDevice>& hw) {
Andy McFaddenc01a79d2012-09-27 16:02:06 -07002026 ALOGD("Screen acquired, type=%d flinger=%p", hw->getDisplayType(), this);
2027 if (hw->isScreenAcquired()) {
2028 // this is expected, e.g. when power manager wakes up during boot
2029 ALOGD(" screen was previously acquired");
2030 return;
2031 }
2032
Mathias Agopian42977342012-08-05 00:40:46 -07002033 hw->acquireScreen();
Andy McFaddenc01a79d2012-09-27 16:02:06 -07002034 int32_t type = hw->getDisplayType();
2035 if (type < DisplayDevice::NUM_DISPLAY_TYPES) {
2036 // built-in display, tell the HWC
2037 getHwComposer().acquire(type);
2038
2039 if (type == DisplayDevice::DISPLAY_PRIMARY) {
2040 // FIXME: eventthread only knows about the main display right now
2041 mEventThread->onScreenAcquired();
2042 }
Mathias Agopiancde87a32012-09-13 14:09:01 -07002043 }
Mathias Agopian20128302012-08-13 18:32:13 -07002044 mVisibleRegionsDirty = true;
2045 repaintEverything();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002046}
2047
Mathias Agopiancde87a32012-09-13 14:09:01 -07002048void SurfaceFlinger::onScreenReleased(const sp<const DisplayDevice>& hw) {
Andy McFaddenc01a79d2012-09-27 16:02:06 -07002049 ALOGD("Screen released, type=%d flinger=%p", hw->getDisplayType(), this);
2050 if (!hw->isScreenAcquired()) {
2051 ALOGD(" screen was previously released");
2052 return;
2053 }
2054
2055 hw->releaseScreen();
2056 int32_t type = hw->getDisplayType();
2057 if (type < DisplayDevice::NUM_DISPLAY_TYPES) {
2058 if (type == DisplayDevice::DISPLAY_PRIMARY) {
Mathias Agopiancde87a32012-09-13 14:09:01 -07002059 // FIXME: eventthread only knows about the main display right now
2060 mEventThread->onScreenReleased();
2061 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07002062
2063 // built-in display, tell the HWC
2064 getHwComposer().release(type);
2065 }
2066 mVisibleRegionsDirty = true;
2067 // from this point on, SF will stop drawing on this display
2068}
2069
2070void SurfaceFlinger::unblank(const sp<IBinder>& display) {
2071 class MessageScreenAcquired : public MessageBase {
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07002072 SurfaceFlinger& mFlinger;
2073 sp<IBinder> mDisplay;
Andy McFaddenc01a79d2012-09-27 16:02:06 -07002074 public:
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07002075 MessageScreenAcquired(SurfaceFlinger& flinger,
2076 const sp<IBinder>& disp) : mFlinger(flinger), mDisplay(disp) { }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07002077 virtual bool handler() {
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07002078 const sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay));
2079 if (hw == NULL) {
2080 ALOGE("Attempt to unblank null display %p", mDisplay.get());
2081 } else if (hw->getDisplayType() >= DisplayDevice::NUM_DISPLAY_TYPES) {
2082 ALOGW("Attempt to unblank virtual display");
2083 } else {
2084 mFlinger.onScreenAcquired(hw);
2085 }
Andy McFaddenc01a79d2012-09-27 16:02:06 -07002086 return true;
2087 }
2088 };
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07002089 sp<MessageBase> msg = new MessageScreenAcquired(*this, display);
2090 postMessageSync(msg);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002091}
2092
Andy McFaddenc01a79d2012-09-27 16:02:06 -07002093void SurfaceFlinger::blank(const sp<IBinder>& display) {
Mathias Agopianb60314a2012-04-10 22:09:54 -07002094 class MessageScreenReleased : public MessageBase {
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07002095 SurfaceFlinger& mFlinger;
2096 sp<IBinder> mDisplay;
Mathias Agopianb60314a2012-04-10 22:09:54 -07002097 public:
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07002098 MessageScreenReleased(SurfaceFlinger& flinger,
2099 const sp<IBinder>& disp) : mFlinger(flinger), mDisplay(disp) { }
Mathias Agopianb60314a2012-04-10 22:09:54 -07002100 virtual bool handler() {
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07002101 const sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay));
2102 if (hw == NULL) {
2103 ALOGE("Attempt to blank null display %p", mDisplay.get());
2104 } else if (hw->getDisplayType() >= DisplayDevice::NUM_DISPLAY_TYPES) {
2105 ALOGW("Attempt to blank virtual display");
2106 } else {
2107 mFlinger.onScreenReleased(hw);
2108 }
Mathias Agopianb60314a2012-04-10 22:09:54 -07002109 return true;
2110 }
2111 };
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07002112 sp<MessageBase> msg = new MessageScreenReleased(*this, display);
2113 postMessageSync(msg);
Mathias Agopianb60314a2012-04-10 22:09:54 -07002114}
2115
2116// ---------------------------------------------------------------------------
2117
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002118status_t SurfaceFlinger::dump(int fd, const Vector<String16>& args)
2119{
Erik Gilling1d21a9c2010-12-01 16:38:01 -08002120 const size_t SIZE = 4096;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002121 char buffer[SIZE];
2122 String8 result;
Mathias Agopian99b49842011-06-27 16:05:52 -07002123
2124 if (!PermissionCache::checkCallingPermission(sDump)) {
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002125 snprintf(buffer, SIZE, "Permission Denial: "
2126 "can't dump SurfaceFlinger from pid=%d, uid=%d\n",
2127 IPCThreadState::self()->getCallingPid(),
2128 IPCThreadState::self()->getCallingUid());
2129 result.append(buffer);
2130 } else {
Mathias Agopian9795c422009-08-26 16:36:26 -07002131 // Try to get the main lock, but don't insist if we can't
2132 // (this would indicate SF is stuck, but we want to be able to
2133 // print something in dumpsys).
2134 int retry = 3;
2135 while (mStateLock.tryLock()<0 && --retry>=0) {
2136 usleep(1000000);
2137 }
2138 const bool locked(retry >= 0);
2139 if (!locked) {
Andreas Huber8b42e8a2010-08-16 08:49:37 -07002140 snprintf(buffer, SIZE,
Mathias Agopian9795c422009-08-26 16:36:26 -07002141 "SurfaceFlinger appears to be unresponsive, "
2142 "dumping anyways (no locks held)\n");
2143 result.append(buffer);
2144 }
2145
Mathias Agopian82d7ab62012-01-19 18:34:40 -08002146 bool dumpAll = true;
2147 size_t index = 0;
Mathias Agopian25e66fc2012-01-28 22:31:55 -08002148 size_t numArgs = args.size();
2149 if (numArgs) {
Mathias Agopian25e66fc2012-01-28 22:31:55 -08002150 if ((index < numArgs) &&
2151 (args[index] == String16("--list"))) {
2152 index++;
2153 listLayersLocked(args, index, result, buffer, SIZE);
Mathias Agopian35aadd62012-03-08 22:01:51 -08002154 dumpAll = false;
Mathias Agopian25e66fc2012-01-28 22:31:55 -08002155 }
2156
2157 if ((index < numArgs) &&
2158 (args[index] == String16("--latency"))) {
Mathias Agopian82d7ab62012-01-19 18:34:40 -08002159 index++;
2160 dumpStatsLocked(args, index, result, buffer, SIZE);
Mathias Agopian35aadd62012-03-08 22:01:51 -08002161 dumpAll = false;
Mathias Agopian82d7ab62012-01-19 18:34:40 -08002162 }
Mathias Agopian25e66fc2012-01-28 22:31:55 -08002163
2164 if ((index < numArgs) &&
2165 (args[index] == String16("--latency-clear"))) {
2166 index++;
2167 clearStatsLocked(args, index, result, buffer, SIZE);
Mathias Agopian35aadd62012-03-08 22:01:51 -08002168 dumpAll = false;
Mathias Agopian25e66fc2012-01-28 22:31:55 -08002169 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002170 }
Mathias Agopian1b5e1022010-04-20 17:55:49 -07002171
Mathias Agopian82d7ab62012-01-19 18:34:40 -08002172 if (dumpAll) {
2173 dumpAllLocked(result, buffer, SIZE);
Mathias Agopian48b888a2011-01-19 16:15:53 -08002174 }
2175
Mathias Agopian9795c422009-08-26 16:36:26 -07002176 if (locked) {
2177 mStateLock.unlock();
2178 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002179 }
2180 write(fd, result.string(), result.size());
2181 return NO_ERROR;
2182}
2183
Mathias Agopian25e66fc2012-01-28 22:31:55 -08002184void SurfaceFlinger::listLayersLocked(const Vector<String16>& args, size_t& index,
2185 String8& result, char* buffer, size_t SIZE) const
2186{
2187 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
2188 const size_t count = currentLayers.size();
2189 for (size_t i=0 ; i<count ; i++) {
Mathias Agopian13127d82013-03-05 17:47:11 -08002190 const sp<Layer>& layer(currentLayers[i]);
Mathias Agopian25e66fc2012-01-28 22:31:55 -08002191 snprintf(buffer, SIZE, "%s\n", layer->getName().string());
2192 result.append(buffer);
2193 }
2194}
2195
Mathias Agopian82d7ab62012-01-19 18:34:40 -08002196void SurfaceFlinger::dumpStatsLocked(const Vector<String16>& args, size_t& index,
2197 String8& result, char* buffer, size_t SIZE) const
2198{
2199 String8 name;
2200 if (index < args.size()) {
2201 name = String8(args[index]);
2202 index++;
2203 }
2204
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002205 const nsecs_t period =
2206 getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
2207 result.appendFormat("%lld\n", period);
2208
2209 if (name.isEmpty()) {
2210 mAnimFrameTracker.dump(result);
2211 } else {
2212 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
2213 const size_t count = currentLayers.size();
2214 for (size_t i=0 ; i<count ; i++) {
Mathias Agopian13127d82013-03-05 17:47:11 -08002215 const sp<Layer>& layer(currentLayers[i]);
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002216 if (name == layer->getName()) {
2217 layer->dumpStats(result, buffer, SIZE);
2218 }
Mathias Agopian82d7ab62012-01-19 18:34:40 -08002219 }
2220 }
2221}
2222
Mathias Agopian25e66fc2012-01-28 22:31:55 -08002223void SurfaceFlinger::clearStatsLocked(const Vector<String16>& args, size_t& index,
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002224 String8& result, char* buffer, size_t SIZE)
Mathias Agopian25e66fc2012-01-28 22:31:55 -08002225{
2226 String8 name;
2227 if (index < args.size()) {
2228 name = String8(args[index]);
2229 index++;
2230 }
2231
2232 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
2233 const size_t count = currentLayers.size();
2234 for (size_t i=0 ; i<count ; i++) {
Mathias Agopian13127d82013-03-05 17:47:11 -08002235 const sp<Layer>& layer(currentLayers[i]);
Mathias Agopian25e66fc2012-01-28 22:31:55 -08002236 if (name.isEmpty() || (name == layer->getName())) {
2237 layer->clearStats();
2238 }
2239 }
Jamie Gennis4b0eba92013-02-05 13:30:24 -08002240
2241 mAnimFrameTracker.clear();
Mathias Agopian25e66fc2012-01-28 22:31:55 -08002242}
2243
Andy McFadden4803b742012-09-24 19:07:20 -07002244/*static*/ void SurfaceFlinger::appendSfConfigString(String8& result)
2245{
2246 static const char* config =
2247 " [sf"
2248#ifdef NO_RGBX_8888
2249 " NO_RGBX_8888"
2250#endif
2251#ifdef HAS_CONTEXT_PRIORITY
2252 " HAS_CONTEXT_PRIORITY"
2253#endif
2254#ifdef NEVER_DEFAULT_TO_ASYNC_MODE
2255 " NEVER_DEFAULT_TO_ASYNC_MODE"
2256#endif
2257#ifdef TARGET_DISABLE_TRIPLE_BUFFERING
2258 " TARGET_DISABLE_TRIPLE_BUFFERING"
2259#endif
2260 "]";
2261 result.append(config);
2262}
2263
Mathias Agopian82d7ab62012-01-19 18:34:40 -08002264void SurfaceFlinger::dumpAllLocked(
2265 String8& result, char* buffer, size_t SIZE) const
2266{
2267 // figure out if we're stuck somewhere
2268 const nsecs_t now = systemTime();
2269 const nsecs_t inSwapBuffers(mDebugInSwapBuffers);
2270 const nsecs_t inTransaction(mDebugInTransaction);
2271 nsecs_t inSwapBuffersDuration = (inSwapBuffers) ? now-inSwapBuffers : 0;
2272 nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
2273
2274 /*
Andy McFadden4803b742012-09-24 19:07:20 -07002275 * Dump library configuration.
2276 */
2277 result.append("Build configuration:");
2278 appendSfConfigString(result);
2279 appendUiConfigString(result);
2280 appendGuiConfigString(result);
2281 result.append("\n");
2282
Mathias Agopianca088332013-03-28 17:44:13 -07002283 result.append("Sync configuration: ");
2284 result.append(SyncFeatures::getInstance().toString());
2285 result.append("\n");
2286
Andy McFadden4803b742012-09-24 19:07:20 -07002287 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08002288 * Dump the visible layer list
2289 */
2290 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
2291 const size_t count = currentLayers.size();
2292 snprintf(buffer, SIZE, "Visible layers (count = %d)\n", count);
2293 result.append(buffer);
2294 for (size_t i=0 ; i<count ; i++) {
Mathias Agopian13127d82013-03-05 17:47:11 -08002295 const sp<Layer>& layer(currentLayers[i]);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08002296 layer->dump(result, buffer, SIZE);
2297 }
2298
2299 /*
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07002300 * Dump Display state
2301 */
2302
Andy McFadden8dfa92f2012-09-17 18:27:17 -07002303 snprintf(buffer, SIZE, "Displays (%d entries)\n", mDisplays.size());
2304 result.append(buffer);
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07002305 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
2306 const sp<const DisplayDevice>& hw(mDisplays[dpy]);
Mathias Agopian1d12d8a2012-09-18 01:38:00 -07002307 hw->dump(result, buffer, SIZE);
Mathias Agopian5f20e2d2012-08-10 18:50:38 -07002308 }
2309
2310 /*
Mathias Agopian82d7ab62012-01-19 18:34:40 -08002311 * Dump SurfaceFlinger global state
2312 */
2313
2314 snprintf(buffer, SIZE, "SurfaceFlinger global state:\n");
2315 result.append(buffer);
2316
Mathias Agopian888c8222012-08-04 21:10:38 -07002317 HWComposer& hwc(getHwComposer());
Mathias Agopian42977342012-08-05 00:40:46 -07002318 sp<const DisplayDevice> hw(getDefaultDisplayDevice());
Mathias Agopian82d7ab62012-01-19 18:34:40 -08002319 const GLExtensions& extensions(GLExtensions::getInstance());
Mathias Agopianca088332013-03-28 17:44:13 -07002320
2321 snprintf(buffer, SIZE, "EGL implementation : %s\n",
2322 eglQueryStringImplementationANDROID(mEGLDisplay, EGL_VERSION));
2323 result.append(buffer);
2324 snprintf(buffer, SIZE, "%s\n",
2325 eglQueryStringImplementationANDROID(mEGLDisplay, EGL_EXTENSIONS));
2326 result.append(buffer);
2327
Mathias Agopian82d7ab62012-01-19 18:34:40 -08002328 snprintf(buffer, SIZE, "GLES: %s, %s, %s\n",
2329 extensions.getVendor(),
2330 extensions.getRenderer(),
2331 extensions.getVersion());
2332 result.append(buffer);
Mathias Agopianca088332013-03-28 17:44:13 -07002333 snprintf(buffer, SIZE, "%s\n", extensions.getExtension());
Mathias Agopian82d7ab62012-01-19 18:34:40 -08002334 result.append(buffer);
2335
Mathias Agopian42977342012-08-05 00:40:46 -07002336 hw->undefinedRegion.dump(result, "undefinedRegion");
Mathias Agopian82d7ab62012-01-19 18:34:40 -08002337 snprintf(buffer, SIZE,
2338 " orientation=%d, canDraw=%d\n",
Mathias Agopian42977342012-08-05 00:40:46 -07002339 hw->getOrientation(), hw->canDraw());
Mathias Agopian82d7ab62012-01-19 18:34:40 -08002340 result.append(buffer);
2341 snprintf(buffer, SIZE,
2342 " last eglSwapBuffers() time: %f us\n"
2343 " last transaction time : %f us\n"
Mathias Agopianc95dbdc2012-02-05 00:19:27 -08002344 " transaction-flags : %08x\n"
Mathias Agopian82d7ab62012-01-19 18:34:40 -08002345 " refresh-rate : %f fps\n"
2346 " x-dpi : %f\n"
Mathias Agopianed985572013-03-22 00:24:39 -07002347 " y-dpi : %f\n"
2348 " EGL_NATIVE_VISUAL_ID : %d\n"
2349 " gpu_to_cpu_unsupported : %d\n"
2350 ,
Mathias Agopian82d7ab62012-01-19 18:34:40 -08002351 mLastSwapBufferTime/1000.0,
2352 mLastTransactionTime/1000.0,
Mathias Agopianc95dbdc2012-02-05 00:19:27 -08002353 mTransactionFlags,
Andy McFaddenb0d1dd32012-09-10 14:08:09 -07002354 1e9 / hwc.getRefreshPeriod(HWC_DISPLAY_PRIMARY),
2355 hwc.getDpiX(HWC_DISPLAY_PRIMARY),
Mathias Agopianed985572013-03-22 00:24:39 -07002356 hwc.getDpiY(HWC_DISPLAY_PRIMARY),
2357 mEGLNativeVisualId,
2358 !mGpuToCpuSupported);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08002359 result.append(buffer);
2360
2361 snprintf(buffer, SIZE, " eglSwapBuffers time: %f us\n",
2362 inSwapBuffersDuration/1000.0);
2363 result.append(buffer);
2364
2365 snprintf(buffer, SIZE, " transaction time: %f us\n",
2366 inTransactionDuration/1000.0);
2367 result.append(buffer);
2368
2369 /*
2370 * VSYNC state
2371 */
2372 mEventThread->dump(result, buffer, SIZE);
2373
2374 /*
2375 * Dump HWComposer state
2376 */
Mathias Agopian82d7ab62012-01-19 18:34:40 -08002377 snprintf(buffer, SIZE, "h/w composer state:\n");
2378 result.append(buffer);
2379 snprintf(buffer, SIZE, " h/w composer %s and %s\n",
2380 hwc.initCheck()==NO_ERROR ? "present" : "not present",
2381 (mDebugDisableHWC || mDebugRegion) ? "disabled" : "enabled");
2382 result.append(buffer);
Mathias Agopiancb558572012-10-04 15:58:54 -07002383 hwc.dump(result, buffer, SIZE);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08002384
2385 /*
2386 * Dump gralloc state
2387 */
2388 const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
2389 alloc.dump(result);
Mathias Agopian82d7ab62012-01-19 18:34:40 -08002390}
2391
Mathias Agopian13127d82013-03-05 17:47:11 -08002392const Vector< sp<Layer> >&
Jesse Hall48bc05b2013-03-21 14:06:52 -07002393SurfaceFlinger::getLayerSortedByZForHwcDisplay(int id) {
Mathias Agopiandb9b41f2012-10-15 16:51:41 -07002394 // Note: mStateLock is held here
Jesse Hall48bc05b2013-03-21 14:06:52 -07002395 wp<IBinder> dpy;
2396 for (size_t i=0 ; i<mDisplays.size() ; i++) {
2397 if (mDisplays.valueAt(i)->getHwcDisplayId() == id) {
2398 dpy = mDisplays.keyAt(i);
2399 break;
2400 }
2401 }
2402 if (dpy == NULL) {
2403 ALOGE("getLayerSortedByZForHwcDisplay: invalid hwc display id %d", id);
2404 // Just use the primary display so we have something to return
2405 dpy = getBuiltInDisplay(DisplayDevice::DISPLAY_PRIMARY);
2406 }
2407 return getDisplayDevice(dpy)->getVisibleLayersSortedByZ();
Mathias Agopiancb558572012-10-04 15:58:54 -07002408}
2409
Keun young Park63f165f2012-08-31 10:53:36 -07002410bool SurfaceFlinger::startDdmConnection()
2411{
2412 void* libddmconnection_dso =
2413 dlopen("libsurfaceflinger_ddmconnection.so", RTLD_NOW);
2414 if (!libddmconnection_dso) {
2415 return false;
2416 }
2417 void (*DdmConnection_start)(const char* name);
2418 DdmConnection_start =
2419 (typeof DdmConnection_start)dlsym(libddmconnection_dso, "DdmConnection_start");
2420 if (!DdmConnection_start) {
2421 dlclose(libddmconnection_dso);
2422 return false;
2423 }
2424 (*DdmConnection_start)(getServiceName());
2425 return true;
2426}
2427
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002428status_t SurfaceFlinger::onTransact(
2429 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
2430{
2431 switch (code) {
2432 case CREATE_CONNECTION:
Mathias Agopian041a0752013-03-15 18:31:56 -07002433 case CREATE_DISPLAY:
Mathias Agopian698c0872011-06-28 19:09:31 -07002434 case SET_TRANSACTION_STATE:
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002435 case BOOT_FINISHED:
Colin Cross8e533062012-06-07 13:17:52 -07002436 case BLANK:
2437 case UNBLANK:
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002438 {
2439 // codes that require permission check
2440 IPCThreadState* ipc = IPCThreadState::self();
2441 const int pid = ipc->getCallingPid();
Mathias Agopiana1ecca92009-05-21 19:21:59 -07002442 const int uid = ipc->getCallingUid();
Mathias Agopian99b49842011-06-27 16:05:52 -07002443 if ((uid != AID_GRAPHICS) &&
2444 !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)) {
Steve Blocke6f43dd2012-01-06 19:20:56 +00002445 ALOGE("Permission Denial: "
Mathias Agopian375f5632009-06-15 18:24:59 -07002446 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
2447 return PERMISSION_DENIED;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002448 }
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07002449 break;
2450 }
2451 case CAPTURE_SCREEN:
2452 {
2453 // codes that require permission check
2454 IPCThreadState* ipc = IPCThreadState::self();
2455 const int pid = ipc->getCallingPid();
2456 const int uid = ipc->getCallingUid();
Mathias Agopian99b49842011-06-27 16:05:52 -07002457 if ((uid != AID_GRAPHICS) &&
2458 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
Steve Blocke6f43dd2012-01-06 19:20:56 +00002459 ALOGE("Permission Denial: "
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07002460 "can't read framebuffer pid=%d, uid=%d", pid, uid);
2461 return PERMISSION_DENIED;
2462 }
2463 break;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002464 }
2465 }
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07002466
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002467 status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
2468 if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
Mathias Agopianb8a55602009-06-26 19:06:36 -07002469 CHECK_INTERFACE(ISurfaceComposer, data, reply);
Glenn Kasten99ed2242011-12-15 09:51:17 -08002470 if (CC_UNLIKELY(!PermissionCache::checkCallingPermission(sHardwareTest))) {
Mathias Agopian375f5632009-06-15 18:24:59 -07002471 IPCThreadState* ipc = IPCThreadState::self();
2472 const int pid = ipc->getCallingPid();
2473 const int uid = ipc->getCallingUid();
Steve Blocke6f43dd2012-01-06 19:20:56 +00002474 ALOGE("Permission Denial: "
Mathias Agopian375f5632009-06-15 18:24:59 -07002475 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002476 return PERMISSION_DENIED;
2477 }
2478 int n;
2479 switch (code) {
Mathias Agopian01b76682009-04-16 20:04:08 -07002480 case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
Mathias Agopian35b48d12010-09-13 22:57:58 -07002481 case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002482 return NO_ERROR;
2483 case 1002: // SHOW_UPDATES
2484 n = data.readInt32();
2485 mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
Mathias Agopian53331da2011-08-22 21:44:41 -07002486 invalidateHwcGeometry();
2487 repaintEverything();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002488 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002489 case 1004:{ // repaint everything
Mathias Agopian53331da2011-08-22 21:44:41 -07002490 repaintEverything();
Mathias Agopiancbb288b2009-09-07 16:32:45 -07002491 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002492 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -07002493 case 1005:{ // force transaction
Mathias Agopiane57f2922012-08-09 16:29:12 -07002494 setTransactionFlags(
2495 eTransactionNeeded|
2496 eDisplayTransactionNeeded|
2497 eTraversalNeeded);
Mathias Agopiancbb288b2009-09-07 16:32:45 -07002498 return NO_ERROR;
2499 }
Mathias Agopian4d143ee2012-02-23 20:05:39 -08002500 case 1006:{ // send empty update
2501 signalRefresh();
2502 return NO_ERROR;
2503 }
Mathias Agopian53331da2011-08-22 21:44:41 -07002504 case 1008: // toggle use of hw composer
2505 n = data.readInt32();
2506 mDebugDisableHWC = n ? 1 : 0;
2507 invalidateHwcGeometry();
2508 repaintEverything();
2509 return NO_ERROR;
Mathias Agopiana4583642011-08-23 18:03:18 -07002510 case 1009: // toggle use of transform hint
2511 n = data.readInt32();
2512 mDebugDisableTransformHint = n ? 1 : 0;
2513 invalidateHwcGeometry();
2514 repaintEverything();
2515 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002516 case 1010: // interrogate.
Mathias Agopian01b76682009-04-16 20:04:08 -07002517 reply->writeInt32(0);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002518 reply->writeInt32(0);
2519 reply->writeInt32(mDebugRegion);
Mathias Agopianb9494d52012-04-18 02:28:45 -07002520 reply->writeInt32(0);
Dianne Hackborn12839be2012-02-06 21:21:05 -08002521 reply->writeInt32(mDebugDisableHWC);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002522 return NO_ERROR;
2523 case 1013: {
2524 Mutex::Autolock _l(mStateLock);
Mathias Agopian42977342012-08-05 00:40:46 -07002525 sp<const DisplayDevice> hw(getDefaultDisplayDevice());
2526 reply->writeInt32(hw->getPageFlipCount());
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002527 }
2528 return NO_ERROR;
2529 }
2530 }
2531 return err;
2532}
2533
Mathias Agopian53331da2011-08-22 21:44:41 -07002534void SurfaceFlinger::repaintEverything() {
Mathias Agopian87baae12012-07-31 12:38:26 -07002535 android_atomic_or(1, &mRepaintEverything);
Mathias Agopian99ce5cd2012-01-31 18:24:27 -08002536 signalTransaction();
Mathias Agopian53331da2011-08-22 21:44:41 -07002537}
2538
Mathias Agopian59119e62010-10-11 12:37:43 -07002539// ---------------------------------------------------------------------------
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002540// Capture screen into an IGraphiBufferProducer
Mathias Agopian9daa5c92010-10-12 16:05:48 -07002541// ---------------------------------------------------------------------------
2542
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002543status_t SurfaceFlinger::captureScreen(const sp<IBinder>& display,
2544 const sp<IGraphicBufferProducer>& producer,
2545 uint32_t reqWidth, uint32_t reqHeight,
Mathias Agopianabe815d2013-03-19 22:22:21 -07002546 uint32_t minLayerZ, uint32_t maxLayerZ,
2547 bool isCpuConsumer) {
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002548
2549 if (CC_UNLIKELY(display == 0))
2550 return BAD_VALUE;
2551
2552 if (CC_UNLIKELY(producer == 0))
2553 return BAD_VALUE;
2554
2555 class MessageCaptureScreen : public MessageBase {
2556 SurfaceFlinger* flinger;
2557 sp<IBinder> display;
2558 sp<IGraphicBufferProducer> producer;
2559 uint32_t reqWidth, reqHeight;
2560 uint32_t minLayerZ,maxLayerZ;
Mathias Agopianabe815d2013-03-19 22:22:21 -07002561 bool isCpuConsumer;
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002562 status_t result;
2563 public:
2564 MessageCaptureScreen(SurfaceFlinger* flinger,
2565 const sp<IBinder>& display,
2566 const sp<IGraphicBufferProducer>& producer,
2567 uint32_t reqWidth, uint32_t reqHeight,
Mathias Agopianabe815d2013-03-19 22:22:21 -07002568 uint32_t minLayerZ, uint32_t maxLayerZ, bool isCpuConsumer)
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002569 : flinger(flinger), display(display), producer(producer),
2570 reqWidth(reqWidth), reqHeight(reqHeight),
2571 minLayerZ(minLayerZ), maxLayerZ(maxLayerZ),
Mathias Agopianabe815d2013-03-19 22:22:21 -07002572 isCpuConsumer(isCpuConsumer),
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002573 result(PERMISSION_DENIED)
2574 {
2575 }
2576 status_t getResult() const {
2577 return result;
2578 }
2579 virtual bool handler() {
2580 Mutex::Autolock _l(flinger->mStateLock);
2581 sp<const DisplayDevice> hw(flinger->getDisplayDevice(display));
Mathias Agopianb4b17302013-03-20 18:36:41 -07002582
Mathias Agopianed985572013-03-22 00:24:39 -07002583 bool useReadPixels = false;
2584 if (isCpuConsumer) {
2585 bool formatSupportedBytBitmap =
2586 (flinger->mEGLNativeVisualId == HAL_PIXEL_FORMAT_RGBA_8888) ||
2587 (flinger->mEGLNativeVisualId == HAL_PIXEL_FORMAT_RGBX_8888);
2588 if (formatSupportedBytBitmap == false) {
2589 // the pixel format we have is not compatible with
2590 // Bitmap.java, which is the likely client of this API,
2591 // so we just revert to glReadPixels() in that case.
2592 useReadPixels = true;
2593 }
2594 if (flinger->mGpuToCpuSupported == false) {
2595 // When we know the GL->CPU path works, we can call
2596 // captureScreenImplLocked() directly, instead of using the
2597 // glReadPixels() workaround.
2598 useReadPixels = true;
2599 }
2600 }
2601
2602 if (!useReadPixels) {
Mathias Agopianb4b17302013-03-20 18:36:41 -07002603 result = flinger->captureScreenImplLocked(hw,
Mathias Agopianabe815d2013-03-19 22:22:21 -07002604 producer, reqWidth, reqHeight, minLayerZ, maxLayerZ);
2605 } else {
Mathias Agopianb4b17302013-03-20 18:36:41 -07002606 result = flinger->captureScreenImplCpuConsumerLocked(hw,
Mathias Agopianabe815d2013-03-19 22:22:21 -07002607 producer, reqWidth, reqHeight, minLayerZ, maxLayerZ);
2608 }
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002609 return true;
2610 }
2611 };
2612
2613 sp<MessageBase> msg = new MessageCaptureScreen(this,
Mathias Agopianabe815d2013-03-19 22:22:21 -07002614 display, producer, reqWidth, reqHeight, minLayerZ, maxLayerZ,
2615 isCpuConsumer);
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002616 status_t res = postMessageSync(msg);
2617 if (res == NO_ERROR) {
2618 res = static_cast<MessageCaptureScreen*>( msg.get() )->getResult();
2619 }
2620 return res;
2621}
2622
2623status_t SurfaceFlinger::captureScreenImplLocked(
2624 const sp<const DisplayDevice>& hw,
2625 const sp<IGraphicBufferProducer>& producer,
2626 uint32_t reqWidth, uint32_t reqHeight,
Mathias Agopianbf2c6a62010-12-10 16:22:31 -08002627 uint32_t minLayerZ, uint32_t maxLayerZ)
Mathias Agopian74c40c02010-09-29 13:02:36 -07002628{
Mathias Agopianfddc28d2012-03-12 15:18:42 -04002629 ATRACE_CALL();
2630
Mathias Agopian74c40c02010-09-29 13:02:36 -07002631 // get screen geometry
Mathias Agopian42977342012-08-05 00:40:46 -07002632 const uint32_t hw_w = hw->getWidth();
2633 const uint32_t hw_h = hw->getHeight();
Mathias Agopian74c40c02010-09-29 13:02:36 -07002634
Mathias Agopian3b1d2b62012-07-11 13:48:17 -07002635 // if we have secure windows on this display, never allow the screen capture
Mathias Agopian42977342012-08-05 00:40:46 -07002636 if (hw->getSecureLayerVisible()) {
Mathias Agopianef7b9c72012-08-10 15:22:19 -07002637 ALOGW("FB is protected: PERMISSION_DENIED");
Mathias Agopian3b1d2b62012-07-11 13:48:17 -07002638 return PERMISSION_DENIED;
2639 }
2640
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002641 if ((reqWidth > hw_w) || (reqHeight > hw_h)) {
2642 ALOGE("size mismatch (%d, %d) > (%d, %d)",
2643 reqWidth, reqHeight, hw_w, hw_h);
Mathias Agopian74c40c02010-09-29 13:02:36 -07002644 return BAD_VALUE;
Mathias Agopian3b1d2b62012-07-11 13:48:17 -07002645 }
Mathias Agopian74c40c02010-09-29 13:02:36 -07002646
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002647 reqWidth = (!reqWidth) ? hw_w : reqWidth;
2648 reqHeight = (!reqHeight) ? hw_h : reqHeight;
2649 const bool filtering = reqWidth != hw_w || reqWidth != hw_h;
Mathias Agopian74c40c02010-09-29 13:02:36 -07002650
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002651 // Create a surface to render into
2652 sp<Surface> surface = new Surface(producer);
2653 ANativeWindow* const window = surface.get();
2654
2655 // set the buffer size to what the user requested
2656 native_window_set_buffers_user_dimensions(window, reqWidth, reqHeight);
2657
2658 // and create the corresponding EGLSurface
2659 EGLSurface eglSurface = eglCreateWindowSurface(
2660 mEGLDisplay, mEGLConfig, window, NULL);
2661 if (eglSurface == EGL_NO_SURFACE) {
2662 ALOGE("captureScreenImplLocked: eglCreateWindowSurface() failed 0x%4x",
2663 eglGetError());
2664 return BAD_VALUE;
2665 }
2666
2667 if (!eglMakeCurrent(mEGLDisplay, eglSurface, eglSurface, mEGLContext)) {
2668 ALOGE("captureScreenImplLocked: eglMakeCurrent() failed 0x%4x",
2669 eglGetError());
2670 eglDestroySurface(mEGLDisplay, eglSurface);
2671 return BAD_VALUE;
2672 }
Mathias Agopianc1d1b0d2011-01-16 14:05:02 -08002673
Mathias Agopian74c40c02010-09-29 13:02:36 -07002674 // make sure to clear all GL error flags
2675 while ( glGetError() != GL_NO_ERROR ) ;
2676
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002677 // set-up our viewport
2678 glViewport(0, 0, reqWidth, reqHeight);
2679 glMatrixMode(GL_PROJECTION);
2680 glLoadIdentity();
2681 glOrthof(0, hw_w, 0, hw_h, 0, 1);
2682 glMatrixMode(GL_MODELVIEW);
2683 glLoadIdentity();
Mathias Agopianfddc28d2012-03-12 15:18:42 -04002684
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002685 // redraw the screen entirely...
2686 glDisable(GL_TEXTURE_EXTERNAL_OES);
2687 glDisable(GL_TEXTURE_2D);
2688 glClearColor(0,0,0,1);
2689 glClear(GL_COLOR_BUFFER_BIT);
Mathias Agopian74c40c02010-09-29 13:02:36 -07002690
Mathias Agopianb7a5b052013-03-11 20:47:24 -07002691 const LayerVector& layers( mDrawingState.layersSortedByZ );
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002692 const size_t count = layers.size();
2693 for (size_t i=0 ; i<count ; ++i) {
Mathias Agopian13127d82013-03-05 17:47:11 -08002694 const sp<Layer>& layer(layers[i]);
Mathias Agopianb7a5b052013-03-11 20:47:24 -07002695 const Layer::State& state(layer->drawingState());
2696 if (state.layerStack == hw->getLayerStack()) {
2697 if (state.z >= minLayerZ && state.z <= maxLayerZ) {
Mathias Agopiana493be52013-03-15 16:08:10 -07002698 if (layer->isVisible()) {
2699 if (filtering) layer->setFiltering(true);
2700 layer->draw(hw);
2701 if (filtering) layer->setFiltering(false);
2702 }
Mathias Agopianb7a5b052013-03-11 20:47:24 -07002703 }
Mathias Agopian74c40c02010-09-29 13:02:36 -07002704 }
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002705 }
Mathias Agopian74c40c02010-09-29 13:02:36 -07002706
Mathias Agopiand5776412013-03-08 13:54:46 -08002707 // compositionComplete is needed for older driver
2708 hw->compositionComplete();
2709
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002710 // and finishing things up...
2711 if (eglSwapBuffers(mEGLDisplay, eglSurface) != EGL_TRUE) {
2712 ALOGE("captureScreenImplLocked: eglSwapBuffers() failed 0x%4x",
2713 eglGetError());
2714 eglDestroySurface(mEGLDisplay, eglSurface);
2715 return BAD_VALUE;
2716 }
2717
2718 eglDestroySurface(mEGLDisplay, eglSurface);
Mathias Agopianabe815d2013-03-19 22:22:21 -07002719
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002720 return NO_ERROR;
2721}
2722
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002723
Mathias Agopianabe815d2013-03-19 22:22:21 -07002724status_t SurfaceFlinger::captureScreenImplCpuConsumerLocked(
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002725 const sp<const DisplayDevice>& hw,
Mathias Agopianabe815d2013-03-19 22:22:21 -07002726 const sp<IGraphicBufferProducer>& producer,
2727 uint32_t reqWidth, uint32_t reqHeight,
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002728 uint32_t minLayerZ, uint32_t maxLayerZ)
2729{
2730 ATRACE_CALL();
2731
2732 if (!GLExtensions::getInstance().haveFramebufferObject()) {
2733 return INVALID_OPERATION;
2734 }
2735
2736 // create the texture that will receive the screenshot, later we'll
2737 // attach a FBO to it so we can call glReadPixels().
2738 GLuint tname;
2739 glGenTextures(1, &tname);
2740 glBindTexture(GL_TEXTURE_2D, tname);
2741 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2742 glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2743
2744 // the GLConsumer will provide the BufferQueue
2745 sp<GLConsumer> consumer = new GLConsumer(tname, true, GL_TEXTURE_2D);
2746 consumer->getBufferQueue()->setDefaultBufferFormat(HAL_PIXEL_FORMAT_RGBA_8888);
2747
2748 // call the new screenshot taking code, passing a BufferQueue to it
2749 status_t result = captureScreenImplLocked(hw,
Mathias Agopianabe815d2013-03-19 22:22:21 -07002750 consumer->getBufferQueue(), reqWidth, reqHeight, minLayerZ, maxLayerZ);
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002751
2752 if (result == NO_ERROR) {
2753 result = consumer->updateTexImage();
2754 if (result == NO_ERROR) {
2755 // create a FBO
2756 GLuint name;
2757 glGenFramebuffersOES(1, &name);
2758 glBindFramebufferOES(GL_FRAMEBUFFER_OES, name);
2759 glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES,
2760 GL_COLOR_ATTACHMENT0_OES, GL_TEXTURE_2D, tname, 0);
2761
Mathias Agopianabe815d2013-03-19 22:22:21 -07002762 reqWidth = consumer->getCurrentBuffer()->getWidth();
2763 reqHeight = consumer->getCurrentBuffer()->getHeight();
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002764
Mathias Agopianabe815d2013-03-19 22:22:21 -07002765 {
2766 // in this block we render the screenshot into the
2767 // CpuConsumer using glReadPixels from our GLConsumer,
2768 // Some older drivers don't support the GL->CPU path so
2769 // have to wrap it with a CPU->CPU path, which is what
2770 // glReadPixels essentially is
2771
2772 sp<Surface> sur = new Surface(producer);
2773 ANativeWindow* window = sur.get();
2774 ANativeWindowBuffer* buffer;
2775 void* vaddr;
2776
2777 if (native_window_api_connect(window,
2778 NATIVE_WINDOW_API_CPU) == NO_ERROR) {
2779 int err = 0;
2780 err = native_window_set_buffers_dimensions(window,
2781 reqWidth, reqHeight);
2782 err |= native_window_set_buffers_format(window,
2783 HAL_PIXEL_FORMAT_RGBA_8888);
2784 err |= native_window_set_usage(window,
2785 GRALLOC_USAGE_SW_READ_OFTEN |
2786 GRALLOC_USAGE_SW_WRITE_OFTEN);
2787
2788 if (err == NO_ERROR) {
2789 if (native_window_dequeue_buffer_and_wait(window,
2790 &buffer) == NO_ERROR) {
2791 sp<GraphicBuffer> buf =
2792 static_cast<GraphicBuffer*>(buffer);
2793 if (buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN,
2794 &vaddr) == NO_ERROR) {
2795 if (buffer->stride != int(reqWidth)) {
2796 // we're unlucky here, glReadPixels is
2797 // not able to deal with a stride not
2798 // equal to the width.
2799 uint32_t* tmp = new uint32_t[reqWidth*reqHeight];
2800 if (tmp != NULL) {
2801 glReadPixels(0, 0, reqWidth, reqHeight,
2802 GL_RGBA, GL_UNSIGNED_BYTE, tmp);
2803 for (size_t y=0 ; y<reqHeight ; y++) {
2804 memcpy((uint32_t*)vaddr + y*buffer->stride,
2805 tmp + y*reqWidth, reqWidth*4);
2806 }
2807 delete [] tmp;
2808 }
2809 } else {
2810 glReadPixels(0, 0, reqWidth, reqHeight,
2811 GL_RGBA, GL_UNSIGNED_BYTE, vaddr);
2812 }
2813 buf->unlock();
2814 }
2815 window->queueBuffer(window, buffer, -1);
2816 }
2817 }
2818 native_window_api_disconnect(window, NATIVE_WINDOW_API_CPU);
Mathias Agopian74c40c02010-09-29 13:02:36 -07002819 }
Mathias Agopian74c40c02010-09-29 13:02:36 -07002820 }
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002821
2822 // back to main framebuffer
2823 glBindFramebufferOES(GL_FRAMEBUFFER_OES, 0);
2824 glDeleteFramebuffersOES(1, &name);
Mathias Agopian74c40c02010-09-29 13:02:36 -07002825 }
Mathias Agopian74c40c02010-09-29 13:02:36 -07002826 }
2827
Mathias Agopian2a9fc492013-03-01 13:42:57 -08002828 glDeleteTextures(1, &tname);
Mathias Agopianc1d1b0d2011-01-16 14:05:02 -08002829
Mathias Agopian2be4e8f2013-03-06 20:42:56 -08002830 DisplayDevice::makeCurrent(mEGLDisplay,
2831 getDefaultDisplayDevice(), mEGLContext);
2832
Mathias Agopian74c40c02010-09-29 13:02:36 -07002833 return result;
2834}
2835
Mathias Agopian1b0b30d2010-09-24 11:26:58 -07002836// ---------------------------------------------------------------------------
2837
Mathias Agopian921e6ac2012-07-23 23:11:29 -07002838SurfaceFlinger::LayerVector::LayerVector() {
2839}
2840
2841SurfaceFlinger::LayerVector::LayerVector(const LayerVector& rhs)
Mathias Agopian13127d82013-03-05 17:47:11 -08002842 : SortedVector<sp<Layer> >(rhs) {
Mathias Agopian921e6ac2012-07-23 23:11:29 -07002843}
2844
2845int SurfaceFlinger::LayerVector::do_compare(const void* lhs,
2846 const void* rhs) const
Mathias Agopianb7e930d2010-06-01 15:12:58 -07002847{
Mathias Agopianbe246f82012-07-31 22:59:38 -07002848 // sort layers per layer-stack, then by z-order and finally by sequence
Mathias Agopian13127d82013-03-05 17:47:11 -08002849 const sp<Layer>& l(*reinterpret_cast<const sp<Layer>*>(lhs));
2850 const sp<Layer>& r(*reinterpret_cast<const sp<Layer>*>(rhs));
Mathias Agopianbe246f82012-07-31 22:59:38 -07002851
2852 uint32_t ls = l->currentState().layerStack;
2853 uint32_t rs = r->currentState().layerStack;
2854 if (ls != rs)
2855 return ls - rs;
2856
Mathias Agopian921e6ac2012-07-23 23:11:29 -07002857 uint32_t lz = l->currentState().z;
2858 uint32_t rz = r->currentState().z;
Mathias Agopianbe246f82012-07-31 22:59:38 -07002859 if (lz != rz)
2860 return lz - rz;
2861
2862 return l->sequence - r->sequence;
Mathias Agopian921e6ac2012-07-23 23:11:29 -07002863}
2864
2865// ---------------------------------------------------------------------------
2866
Mathias Agopian3ee454a2012-08-27 16:28:24 -07002867SurfaceFlinger::DisplayDeviceState::DisplayDeviceState()
2868 : type(DisplayDevice::DISPLAY_ID_INVALID) {
Mathias Agopiane57f2922012-08-09 16:29:12 -07002869}
2870
Mathias Agopian3ee454a2012-08-27 16:28:24 -07002871SurfaceFlinger::DisplayDeviceState::DisplayDeviceState(DisplayDevice::DisplayType type)
Jesse Hall01e29052013-02-19 16:13:35 -08002872 : type(type), layerStack(DisplayDevice::NO_LAYER_STACK), orientation(0) {
Mathias Agopianda8d0a52012-09-04 15:05:38 -07002873 viewport.makeInvalid();
2874 frame.makeInvalid();
Mathias Agopianb7e930d2010-06-01 15:12:58 -07002875}
2876
2877// ---------------------------------------------------------------------------
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002878
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08002879}; // namespace android