1 /*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
18
19 #include <stdint.h>
20 #include <sys/types.h>
21 #include <errno.h>
22 #include <math.h>
23 #include <dlfcn.h>
24 #include <inttypes.h>
25 #include <stdatomic.h>
26
27 #include <EGL/egl.h>
28
29 #include <cutils/log.h>
30 #include <cutils/properties.h>
31
32 #include <binder/IPCThreadState.h>
33 #include <binder/IServiceManager.h>
34 #include <binder/MemoryHeapBase.h>
35 #include <binder/PermissionCache.h>
36
37 #include <ui/DisplayInfo.h>
38 #include <ui/DisplayStatInfo.h>
39
40 #include <gui/BitTube.h>
41 #include <gui/BufferQueue.h>
42 #include <gui/GuiConfig.h>
43 #include <gui/IDisplayEventConnection.h>
44 #include <gui/Surface.h>
45 #include <gui/GraphicBufferAlloc.h>
46
47 #include <ui/GraphicBufferAllocator.h>
48 #include <ui/PixelFormat.h>
49 #include <ui/UiConfig.h>
50
51 #include <utils/misc.h>
52 #include <utils/String8.h>
53 #include <utils/String16.h>
54 #include <utils/StopWatch.h>
55 #include <utils/Trace.h>
56
57 #include <private/android_filesystem_config.h>
58 #include <private/gui/SyncFeatures.h>
59
60 #include "Client.h"
61 #include "clz.h"
62 #include "Colorizer.h"
63 #include "DdmConnection.h"
64 #include "DisplayDevice.h"
65 #include "DispSync.h"
66 #include "EventControlThread.h"
67 #include "EventThread.h"
68 #include "Layer.h"
69 #include "LayerDim.h"
70 #include "SurfaceFlinger.h"
71
72 #include "DisplayHardware/FramebufferSurface.h"
73 #include "DisplayHardware/HWComposer.h"
74 #include "DisplayHardware/VirtualDisplaySurface.h"
75
76 #include "Effects/Daltonizer.h"
77
78 #include "RenderEngine/RenderEngine.h"
79 #include <cutils/compiler.h>
80
81 #define DISPLAY_COUNT 1
82
83 /*
84 * DEBUG_SCREENSHOTS: set to true to check that screenshots are not all
85 * black pixels.
86 */
87 #define DEBUG_SCREENSHOTS false
88
89 EGLAPI const char* eglQueryStringImplementationANDROID(EGLDisplay dpy, EGLint name);
90
91 namespace android {
92
93 // This is the phase offset in nanoseconds of the software vsync event
94 // relative to the vsync event reported by HWComposer. The software vsync
95 // event is when SurfaceFlinger and Choreographer-based applications run each
96 // frame.
97 //
98 // This phase offset allows adjustment of the minimum latency from application
99 // wake-up (by Choregographer) time to the time at which the resulting window
100 // image is displayed. This value may be either positive (after the HW vsync)
101 // or negative (before the HW vsync). Setting it to 0 will result in a
102 // minimum latency of two vsync periods because the app and SurfaceFlinger
103 // will run just after the HW vsync. Setting it to a positive number will
104 // result in the minimum latency being:
105 //
106 // (2 * VSYNC_PERIOD - (vsyncPhaseOffsetNs % VSYNC_PERIOD))
107 //
108 // Note that reducing this latency makes it more likely for the applications
109 // to not have their window content image ready in time. When this happens
110 // the latency will end up being an additional vsync period, and animations
111 // will hiccup. Therefore, this latency should be tuned somewhat
112 // conservatively (or at least with awareness of the trade-off being made).
113 static const int64_t vsyncPhaseOffsetNs = VSYNC_EVENT_PHASE_OFFSET_NS;
114
115 // This is the phase offset at which SurfaceFlinger's composition runs.
116 static const int64_t sfVsyncPhaseOffsetNs = SF_VSYNC_EVENT_PHASE_OFFSET_NS;
117
118 // ---------------------------------------------------------------------------
119
120 const String16 sHardwareTest("android.permission.HARDWARE_TEST");
121 const String16 sAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER");
122 const String16 sReadFramebuffer("android.permission.READ_FRAME_BUFFER");
123 const String16 sDump("android.permission.DUMP");
124
125 // ---------------------------------------------------------------------------
126
SurfaceFlinger()127 SurfaceFlinger::SurfaceFlinger()
128 : BnSurfaceComposer(),
129 mTransactionFlags(0),
130 mTransactionPending(false),
131 mAnimTransactionPending(false),
132 mLayersRemoved(false),
133 mRepaintEverything(0),
134 mRenderEngine(NULL),
135 mBootTime(systemTime()),
136 mVisibleRegionsDirty(false),
137 mHwWorkListDirty(false),
138 mAnimCompositionPending(false),
139 mDebugRegion(0),
140 mDebugDDMS(0),
141 mDebugDisableHWC(0),
142 mDebugDisableTransformHint(0),
143 mDebugInSwapBuffers(0),
144 mLastSwapBufferTime(0),
145 mDebugInTransaction(0),
146 mLastTransactionTime(0),
147 mBootFinished(false),
148 mPrimaryHWVsyncEnabled(false),
149 mHWVsyncAvailable(false),
150 mDaltonize(false),
151 mHasColorMatrix(false)
152 {
153 ALOGI("SurfaceFlinger is starting");
154
155 // debugging stuff...
156 char value[PROPERTY_VALUE_MAX];
157
158 property_get("ro.bq.gpu_to_cpu_unsupported", value, "0");
159 mGpuToCpuSupported = !atoi(value);
160
161 property_get("debug.sf.showupdates", value, "0");
162 mDebugRegion = atoi(value);
163
164 property_get("debug.sf.ddms", value, "0");
165 mDebugDDMS = atoi(value);
166 if (mDebugDDMS) {
167 if (!startDdmConnection()) {
168 // start failed, and DDMS debugging not enabled
169 mDebugDDMS = 0;
170 }
171 }
172 ALOGI_IF(mDebugRegion, "showupdates enabled");
173 ALOGI_IF(mDebugDDMS, "DDMS debugging enabled");
174 }
175
onFirstRef()176 void SurfaceFlinger::onFirstRef()
177 {
178 mEventQueue.init(this);
179 }
180
~SurfaceFlinger()181 SurfaceFlinger::~SurfaceFlinger()
182 {
183 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
184 eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
185 eglTerminate(display);
186 }
187
binderDied(const wp<IBinder> &)188 void SurfaceFlinger::binderDied(const wp<IBinder>& /* who */)
189 {
190 // the window manager died on us. prepare its eulogy.
191
192 // restore initial conditions (default device unblank, etc)
193 initializeDisplays();
194
195 // restart the boot-animation
196 startBootAnim();
197 }
198
createConnection()199 sp<ISurfaceComposerClient> SurfaceFlinger::createConnection()
200 {
201 sp<ISurfaceComposerClient> bclient;
202 sp<Client> client(new Client(this));
203 status_t err = client->initCheck();
204 if (err == NO_ERROR) {
205 bclient = client;
206 }
207 return bclient;
208 }
209
createDisplay(const String8 & displayName,bool secure)210 sp<IBinder> SurfaceFlinger::createDisplay(const String8& displayName,
211 bool secure)
212 {
213 class DisplayToken : public BBinder {
214 sp<SurfaceFlinger> flinger;
215 virtual ~DisplayToken() {
216 // no more references, this display must be terminated
217 Mutex::Autolock _l(flinger->mStateLock);
218 flinger->mCurrentState.displays.removeItem(this);
219 flinger->setTransactionFlags(eDisplayTransactionNeeded);
220 }
221 public:
222 DisplayToken(const sp<SurfaceFlinger>& flinger)
223 : flinger(flinger) {
224 }
225 };
226
227 sp<BBinder> token = new DisplayToken(this);
228
229 Mutex::Autolock _l(mStateLock);
230 DisplayDeviceState info(DisplayDevice::DISPLAY_VIRTUAL);
231 info.displayName = displayName;
232 info.isSecure = secure;
233 mCurrentState.displays.add(token, info);
234
235 return token;
236 }
237
destroyDisplay(const sp<IBinder> & display)238 void SurfaceFlinger::destroyDisplay(const sp<IBinder>& display) {
239 Mutex::Autolock _l(mStateLock);
240
241 ssize_t idx = mCurrentState.displays.indexOfKey(display);
242 if (idx < 0) {
243 ALOGW("destroyDisplay: invalid display token");
244 return;
245 }
246
247 const DisplayDeviceState& info(mCurrentState.displays.valueAt(idx));
248 if (!info.isVirtualDisplay()) {
249 ALOGE("destroyDisplay called for non-virtual display");
250 return;
251 }
252
253 mCurrentState.displays.removeItemsAt(idx);
254 setTransactionFlags(eDisplayTransactionNeeded);
255 }
256
createBuiltinDisplayLocked(DisplayDevice::DisplayType type)257 void SurfaceFlinger::createBuiltinDisplayLocked(DisplayDevice::DisplayType type) {
258 ALOGW_IF(mBuiltinDisplays[type],
259 "Overwriting display token for display type %d", type);
260 mBuiltinDisplays[type] = new BBinder();
261 DisplayDeviceState info(type);
262 // All non-virtual displays are currently considered secure.
263 info.isSecure = true;
264 mCurrentState.displays.add(mBuiltinDisplays[type], info);
265 }
266
getBuiltInDisplay(int32_t id)267 sp<IBinder> SurfaceFlinger::getBuiltInDisplay(int32_t id) {
268 if (uint32_t(id) >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
269 ALOGE("getDefaultDisplay: id=%d is not a valid default display id", id);
270 return NULL;
271 }
272 return mBuiltinDisplays[id];
273 }
274
createGraphicBufferAlloc()275 sp<IGraphicBufferAlloc> SurfaceFlinger::createGraphicBufferAlloc()
276 {
277 sp<GraphicBufferAlloc> gba(new GraphicBufferAlloc());
278 return gba;
279 }
280
bootFinished()281 void SurfaceFlinger::bootFinished()
282 {
283 const nsecs_t now = systemTime();
284 const nsecs_t duration = now - mBootTime;
285 ALOGI("Boot is finished (%ld ms)", long(ns2ms(duration)) );
286 mBootFinished = true;
287
288 // wait patiently for the window manager death
289 const String16 name("window");
290 sp<IBinder> window(defaultServiceManager()->getService(name));
291 if (window != 0) {
292 window->linkToDeath(static_cast<IBinder::DeathRecipient*>(this));
293 }
294
295 // stop boot animation
296 // formerly we would just kill the process, but we now ask it to exit so it
297 // can choose where to stop the animation.
298 property_set("service.bootanim.exit", "1");
299 }
300
deleteTextureAsync(uint32_t texture)301 void SurfaceFlinger::deleteTextureAsync(uint32_t texture) {
302 class MessageDestroyGLTexture : public MessageBase {
303 RenderEngine& engine;
304 uint32_t texture;
305 public:
306 MessageDestroyGLTexture(RenderEngine& engine, uint32_t texture)
307 : engine(engine), texture(texture) {
308 }
309 virtual bool handler() {
310 engine.deleteTextures(1, &texture);
311 return true;
312 }
313 };
314 postMessageAsync(new MessageDestroyGLTexture(getRenderEngine(), texture));
315 }
316
317 class DispSyncSource : public VSyncSource, private DispSync::Callback {
318 public:
DispSyncSource(DispSync * dispSync,nsecs_t phaseOffset,bool traceVsync,const char * label)319 DispSyncSource(DispSync* dispSync, nsecs_t phaseOffset, bool traceVsync,
320 const char* label) :
321 mValue(0),
322 mPhaseOffset(phaseOffset),
323 mTraceVsync(traceVsync),
324 mVsyncOnLabel(String8::format("VsyncOn-%s", label)),
325 mVsyncEventLabel(String8::format("VSYNC-%s", label)),
326 mDispSync(dispSync) {}
327
~DispSyncSource()328 virtual ~DispSyncSource() {}
329
setVSyncEnabled(bool enable)330 virtual void setVSyncEnabled(bool enable) {
331 // Do NOT lock the mutex here so as to avoid any mutex ordering issues
332 // with locking it in the onDispSyncEvent callback.
333 if (enable) {
334 status_t err = mDispSync->addEventListener(mPhaseOffset,
335 static_cast<DispSync::Callback*>(this));
336 if (err != NO_ERROR) {
337 ALOGE("error registering vsync callback: %s (%d)",
338 strerror(-err), err);
339 }
340 //ATRACE_INT(mVsyncOnLabel.string(), 1);
341 } else {
342 status_t err = mDispSync->removeEventListener(
343 static_cast<DispSync::Callback*>(this));
344 if (err != NO_ERROR) {
345 ALOGE("error unregistering vsync callback: %s (%d)",
346 strerror(-err), err);
347 }
348 //ATRACE_INT(mVsyncOnLabel.string(), 0);
349 }
350 }
351
setCallback(const sp<VSyncSource::Callback> & callback)352 virtual void setCallback(const sp<VSyncSource::Callback>& callback) {
353 Mutex::Autolock lock(mMutex);
354 mCallback = callback;
355 }
356
357 private:
onDispSyncEvent(nsecs_t when)358 virtual void onDispSyncEvent(nsecs_t when) {
359 sp<VSyncSource::Callback> callback;
360 {
361 Mutex::Autolock lock(mMutex);
362 callback = mCallback;
363
364 if (mTraceVsync) {
365 mValue = (mValue + 1) % 2;
366 ATRACE_INT(mVsyncEventLabel.string(), mValue);
367 }
368 }
369
370 if (callback != NULL) {
371 callback->onVSyncEvent(when);
372 }
373 }
374
375 int mValue;
376
377 const nsecs_t mPhaseOffset;
378 const bool mTraceVsync;
379 const String8 mVsyncOnLabel;
380 const String8 mVsyncEventLabel;
381
382 DispSync* mDispSync;
383 sp<VSyncSource::Callback> mCallback;
384 Mutex mMutex;
385 };
386
init()387 void SurfaceFlinger::init() {
388 ALOGI( "SurfaceFlinger's main thread ready to run. "
389 "Initializing graphics H/W...");
390
391 status_t err;
392 Mutex::Autolock _l(mStateLock);
393
394 // initialize EGL for the default display
395 mEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
396 eglInitialize(mEGLDisplay, NULL, NULL);
397
398 // Initialize the H/W composer object. There may or may not be an
399 // actual hardware composer underneath.
400 mHwc = new HWComposer(this,
401 *static_cast<HWComposer::EventHandler *>(this));
402
403 // get a RenderEngine for the given display / config (can't fail)
404 mRenderEngine = RenderEngine::create(mEGLDisplay, mHwc->getVisualID());
405
406 // retrieve the EGL context that was selected/created
407 mEGLContext = mRenderEngine->getEGLContext();
408
409 LOG_ALWAYS_FATAL_IF(mEGLContext == EGL_NO_CONTEXT,
410 "couldn't create EGLContext");
411
412 // initialize our non-virtual displays
413 for (size_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {
414 DisplayDevice::DisplayType type((DisplayDevice::DisplayType)i);
415 // set-up the displays that are already connected
416 if (mHwc->isConnected(i) || type==DisplayDevice::DISPLAY_PRIMARY) {
417 // All non-virtual displays are currently considered secure.
418 bool isSecure = true;
419 createBuiltinDisplayLocked(type);
420 wp<IBinder> token = mBuiltinDisplays[i];
421
422 sp<IGraphicBufferProducer> producer;
423 sp<IGraphicBufferConsumer> consumer;
424 BufferQueue::createBufferQueue(&producer, &consumer,
425 new GraphicBufferAlloc());
426
427 sp<FramebufferSurface> fbs = new FramebufferSurface(*mHwc, i,
428 consumer);
429 int32_t hwcId = allocateHwcDisplayId(type);
430 sp<DisplayDevice> hw = new DisplayDevice(this,
431 type, hwcId, mHwc->getFormat(hwcId), isSecure, token,
432 fbs, producer,
433 mRenderEngine->getEGLConfig());
434 if (i > DisplayDevice::DISPLAY_PRIMARY) {
435 // FIXME: currently we don't get blank/unblank requests
436 // for displays other than the main display, so we always
437 // assume a connected display is unblanked.
438 ALOGD("marking display %zu as acquired/unblanked", i);
439 hw->setPowerMode(HWC_POWER_MODE_NORMAL);
440 }
441 mDisplays.add(token, hw);
442 }
443 }
444
445 // make the GLContext current so that we can create textures when creating Layers
446 // (which may happens before we render something)
447 getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
448
449 // start the EventThread
450 sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync,
451 vsyncPhaseOffsetNs, true, "app");
452 mEventThread = new EventThread(vsyncSrc);
453 sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,
454 sfVsyncPhaseOffsetNs, true, "sf");
455 mSFEventThread = new EventThread(sfVsyncSrc);
456 mEventQueue.setEventThread(mSFEventThread);
457
458 mEventControlThread = new EventControlThread(this);
459 mEventControlThread->run("EventControl", PRIORITY_URGENT_DISPLAY);
460
461 // set a fake vsync period if there is no HWComposer
462 if (mHwc->initCheck() != NO_ERROR) {
463 mPrimaryDispSync.setPeriod(16666667);
464 }
465
466 // initialize our drawing state
467 mDrawingState = mCurrentState;
468
469 // set initial conditions (e.g. unblank default device)
470 initializeDisplays();
471
472 // start boot animation
473 startBootAnim();
474 }
475
allocateHwcDisplayId(DisplayDevice::DisplayType type)476 int32_t SurfaceFlinger::allocateHwcDisplayId(DisplayDevice::DisplayType type) {
477 return (uint32_t(type) < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) ?
478 type : mHwc->allocateDisplayId();
479 }
480
startBootAnim()481 void SurfaceFlinger::startBootAnim() {
482 // start boot animation
483 property_set("service.bootanim.exit", "0");
484 property_set("ctl.start", "bootanim");
485 }
486
getMaxTextureSize() const487 size_t SurfaceFlinger::getMaxTextureSize() const {
488 return mRenderEngine->getMaxTextureSize();
489 }
490
getMaxViewportDims() const491 size_t SurfaceFlinger::getMaxViewportDims() const {
492 return mRenderEngine->getMaxViewportDims();
493 }
494
495 // ----------------------------------------------------------------------------
496
authenticateSurfaceTexture(const sp<IGraphicBufferProducer> & bufferProducer) const497 bool SurfaceFlinger::authenticateSurfaceTexture(
498 const sp<IGraphicBufferProducer>& bufferProducer) const {
499 Mutex::Autolock _l(mStateLock);
500 sp<IBinder> surfaceTextureBinder(bufferProducer->asBinder());
501 return mGraphicBufferProducerList.indexOf(surfaceTextureBinder) >= 0;
502 }
503
getDisplayConfigs(const sp<IBinder> & display,Vector<DisplayInfo> * configs)504 status_t SurfaceFlinger::getDisplayConfigs(const sp<IBinder>& display,
505 Vector<DisplayInfo>* configs) {
506 if (configs == NULL) {
507 return BAD_VALUE;
508 }
509
510 int32_t type = NAME_NOT_FOUND;
511 for (int i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {
512 if (display == mBuiltinDisplays[i]) {
513 type = i;
514 break;
515 }
516 }
517
518 if (type < 0) {
519 return type;
520 }
521
522 // TODO: Not sure if display density should handled by SF any longer
523 class Density {
524 static int getDensityFromProperty(char const* propName) {
525 char property[PROPERTY_VALUE_MAX];
526 int density = 0;
527 if (property_get(propName, property, NULL) > 0) {
528 density = atoi(property);
529 }
530 return density;
531 }
532 public:
533 static int getEmuDensity() {
534 return getDensityFromProperty("qemu.sf.lcd_density"); }
535 static int getBuildDensity() {
536 return getDensityFromProperty("ro.sf.lcd_density"); }
537 };
538
539 configs->clear();
540
541 const Vector<HWComposer::DisplayConfig>& hwConfigs =
542 getHwComposer().getConfigs(type);
543 for (size_t c = 0; c < hwConfigs.size(); ++c) {
544 const HWComposer::DisplayConfig& hwConfig = hwConfigs[c];
545 DisplayInfo info = DisplayInfo();
546
547 float xdpi = hwConfig.xdpi;
548 float ydpi = hwConfig.ydpi;
549
550 if (type == DisplayDevice::DISPLAY_PRIMARY) {
551 // The density of the device is provided by a build property
552 float density = Density::getBuildDensity() / 160.0f;
553 if (density == 0) {
554 // the build doesn't provide a density -- this is wrong!
555 // use xdpi instead
556 ALOGE("ro.sf.lcd_density must be defined as a build property");
557 density = xdpi / 160.0f;
558 }
559 if (Density::getEmuDensity()) {
560 // if "qemu.sf.lcd_density" is specified, it overrides everything
561 xdpi = ydpi = density = Density::getEmuDensity();
562 density /= 160.0f;
563 }
564 info.density = density;
565
566 // TODO: this needs to go away (currently needed only by webkit)
567 sp<const DisplayDevice> hw(getDefaultDisplayDevice());
568 info.orientation = hw->getOrientation();
569 } else {
570 // TODO: where should this value come from?
571 static const int TV_DENSITY = 213;
572 info.density = TV_DENSITY / 160.0f;
573 info.orientation = 0;
574 }
575
576 info.w = hwConfig.width;
577 info.h = hwConfig.height;
578 info.xdpi = xdpi;
579 info.ydpi = ydpi;
580 info.fps = float(1e9 / hwConfig.refresh);
581 info.appVsyncOffset = VSYNC_EVENT_PHASE_OFFSET_NS;
582
583 // This is how far in advance a buffer must be queued for
584 // presentation at a given time. If you want a buffer to appear
585 // on the screen at time N, you must submit the buffer before
586 // (N - presentationDeadline).
587 //
588 // Normally it's one full refresh period (to give SF a chance to
589 // latch the buffer), but this can be reduced by configuring a
590 // DispSync offset. Any additional delays introduced by the hardware
591 // composer or panel must be accounted for here.
592 //
593 // We add an additional 1ms to allow for processing time and
594 // differences between the ideal and actual refresh rate.
595 info.presentationDeadline =
596 hwConfig.refresh - SF_VSYNC_EVENT_PHASE_OFFSET_NS + 1000000;
597
598 // All non-virtual displays are currently considered secure.
599 info.secure = true;
600
601 configs->push_back(info);
602 }
603
604 return NO_ERROR;
605 }
606
getDisplayStats(const sp<IBinder> & display,DisplayStatInfo * stats)607 status_t SurfaceFlinger::getDisplayStats(const sp<IBinder>& display,
608 DisplayStatInfo* stats) {
609 if (stats == NULL) {
610 return BAD_VALUE;
611 }
612
613 // FIXME for now we always return stats for the primary display
614 memset(stats, 0, sizeof(*stats));
615 stats->vsyncTime = mPrimaryDispSync.computeNextRefresh(0);
616 stats->vsyncPeriod = mPrimaryDispSync.getPeriod();
617 return NO_ERROR;
618 }
619
getActiveConfig(const sp<IBinder> & display)620 int SurfaceFlinger::getActiveConfig(const sp<IBinder>& display) {
621 return getDisplayDevice(display)->getActiveConfig();
622 }
623
setActiveConfigInternal(const sp<DisplayDevice> & hw,int mode)624 void SurfaceFlinger::setActiveConfigInternal(const sp<DisplayDevice>& hw, int mode) {
625 ALOGD("Set active config mode=%d, type=%d flinger=%p", mode, hw->getDisplayType(),
626 this);
627 int32_t type = hw->getDisplayType();
628 int currentMode = hw->getActiveConfig();
629
630 if (mode == currentMode) {
631 ALOGD("Screen type=%d is already mode=%d", hw->getDisplayType(), mode);
632 return;
633 }
634
635 if (type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
636 ALOGW("Trying to set config for virtual display");
637 return;
638 }
639
640 hw->setActiveConfig(mode);
641 getHwComposer().setActiveConfig(type, mode);
642 }
643
setActiveConfig(const sp<IBinder> & display,int mode)644 status_t SurfaceFlinger::setActiveConfig(const sp<IBinder>& display, int mode) {
645 class MessageSetActiveConfig: public MessageBase {
646 SurfaceFlinger& mFlinger;
647 sp<IBinder> mDisplay;
648 int mMode;
649 public:
650 MessageSetActiveConfig(SurfaceFlinger& flinger, const sp<IBinder>& disp,
651 int mode) :
652 mFlinger(flinger), mDisplay(disp) { mMode = mode; }
653 virtual bool handler() {
654 Vector<DisplayInfo> configs;
655 mFlinger.getDisplayConfigs(mDisplay, &configs);
656 if(mMode < 0 || mMode >= configs.size()) {
657 ALOGE("Attempt to set active config = %d for display with %zu configs",
658 mMode, configs.size());
659 }
660 sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay));
661 if (hw == NULL) {
662 ALOGE("Attempt to set active config = %d for null display %p",
663 mMode, mDisplay.get());
664 } else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) {
665 ALOGW("Attempt to set active config = %d for virtual display",
666 mMode);
667 } else {
668 mFlinger.setActiveConfigInternal(hw, mMode);
669 }
670 return true;
671 }
672 };
673 sp<MessageBase> msg = new MessageSetActiveConfig(*this, display, mode);
674 postMessageSync(msg);
675 return NO_ERROR;
676 }
677
clearAnimationFrameStats()678 status_t SurfaceFlinger::clearAnimationFrameStats() {
679 Mutex::Autolock _l(mStateLock);
680 mAnimFrameTracker.clearStats();
681 return NO_ERROR;
682 }
683
getAnimationFrameStats(FrameStats * outStats) const684 status_t SurfaceFlinger::getAnimationFrameStats(FrameStats* outStats) const {
685 Mutex::Autolock _l(mStateLock);
686 mAnimFrameTracker.getStats(outStats);
687 return NO_ERROR;
688 }
689
690 // ----------------------------------------------------------------------------
691
createDisplayEventConnection()692 sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection() {
693 return mEventThread->createEventConnection();
694 }
695
696 // ----------------------------------------------------------------------------
697
waitForEvent()698 void SurfaceFlinger::waitForEvent() {
699 mEventQueue.waitMessage();
700 }
701
signalTransaction()702 void SurfaceFlinger::signalTransaction() {
703 mEventQueue.invalidate();
704 }
705
signalLayerUpdate()706 void SurfaceFlinger::signalLayerUpdate() {
707 mEventQueue.invalidate();
708 }
709
signalRefresh()710 void SurfaceFlinger::signalRefresh() {
711 mEventQueue.refresh();
712 }
713
postMessageAsync(const sp<MessageBase> & msg,nsecs_t reltime,uint32_t)714 status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg,
715 nsecs_t reltime, uint32_t /* flags */) {
716 return mEventQueue.postMessage(msg, reltime);
717 }
718
postMessageSync(const sp<MessageBase> & msg,nsecs_t reltime,uint32_t)719 status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,
720 nsecs_t reltime, uint32_t /* flags */) {
721 status_t res = mEventQueue.postMessage(msg, reltime);
722 if (res == NO_ERROR) {
723 msg->wait();
724 }
725 return res;
726 }
727
run()728 void SurfaceFlinger::run() {
729 do {
730 waitForEvent();
731 } while (true);
732 }
733
enableHardwareVsync()734 void SurfaceFlinger::enableHardwareVsync() {
735 Mutex::Autolock _l(mHWVsyncLock);
736 if (!mPrimaryHWVsyncEnabled && mHWVsyncAvailable) {
737 mPrimaryDispSync.beginResync();
738 //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, true);
739 mEventControlThread->setVsyncEnabled(true);
740 mPrimaryHWVsyncEnabled = true;
741 }
742 }
743
resyncToHardwareVsync(bool makeAvailable)744 void SurfaceFlinger::resyncToHardwareVsync(bool makeAvailable) {
745 Mutex::Autolock _l(mHWVsyncLock);
746
747 if (makeAvailable) {
748 mHWVsyncAvailable = true;
749 } else if (!mHWVsyncAvailable) {
750 ALOGE("resyncToHardwareVsync called when HW vsync unavailable");
751 return;
752 }
753
754 const nsecs_t period =
755 getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
756
757 mPrimaryDispSync.reset();
758 mPrimaryDispSync.setPeriod(period);
759
760 if (!mPrimaryHWVsyncEnabled) {
761 mPrimaryDispSync.beginResync();
762 //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, true);
763 mEventControlThread->setVsyncEnabled(true);
764 mPrimaryHWVsyncEnabled = true;
765 }
766 }
767
disableHardwareVsync(bool makeUnavailable)768 void SurfaceFlinger::disableHardwareVsync(bool makeUnavailable) {
769 Mutex::Autolock _l(mHWVsyncLock);
770 if (mPrimaryHWVsyncEnabled) {
771 //eventControl(HWC_DISPLAY_PRIMARY, SurfaceFlinger::EVENT_VSYNC, false);
772 mEventControlThread->setVsyncEnabled(false);
773 mPrimaryDispSync.endResync();
774 mPrimaryHWVsyncEnabled = false;
775 }
776 if (makeUnavailable) {
777 mHWVsyncAvailable = false;
778 }
779 }
780
onVSyncReceived(int type,nsecs_t timestamp)781 void SurfaceFlinger::onVSyncReceived(int type, nsecs_t timestamp) {
782 bool needsHwVsync = false;
783
784 { // Scope for the lock
785 Mutex::Autolock _l(mHWVsyncLock);
786 if (type == 0 && mPrimaryHWVsyncEnabled) {
787 needsHwVsync = mPrimaryDispSync.addResyncSample(timestamp);
788 }
789 }
790
791 if (needsHwVsync) {
792 enableHardwareVsync();
793 } else {
794 disableHardwareVsync(false);
795 }
796 }
797
onHotplugReceived(int type,bool connected)798 void SurfaceFlinger::onHotplugReceived(int type, bool connected) {
799 if (mEventThread == NULL) {
800 // This is a temporary workaround for b/7145521. A non-null pointer
801 // does not mean EventThread has finished initializing, so this
802 // is not a correct fix.
803 ALOGW("WARNING: EventThread not started, ignoring hotplug");
804 return;
805 }
806
807 if (uint32_t(type) < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
808 Mutex::Autolock _l(mStateLock);
809 if (connected) {
810 createBuiltinDisplayLocked((DisplayDevice::DisplayType)type);
811 } else {
812 mCurrentState.displays.removeItem(mBuiltinDisplays[type]);
813 mBuiltinDisplays[type].clear();
814 }
815 setTransactionFlags(eDisplayTransactionNeeded);
816
817 // Defer EventThread notification until SF has updated mDisplays.
818 }
819 }
820
eventControl(int disp,int event,int enabled)821 void SurfaceFlinger::eventControl(int disp, int event, int enabled) {
822 ATRACE_CALL();
823 getHwComposer().eventControl(disp, event, enabled);
824 }
825
onMessageReceived(int32_t what)826 void SurfaceFlinger::onMessageReceived(int32_t what) {
827 ATRACE_CALL();
828 switch (what) {
829 case MessageQueue::TRANSACTION:
830 handleMessageTransaction();
831 break;
832 case MessageQueue::INVALIDATE:
833 handleMessageTransaction();
834 handleMessageInvalidate();
835 signalRefresh();
836 break;
837 case MessageQueue::REFRESH:
838 handleMessageRefresh();
839 break;
840 }
841 }
842
handleMessageTransaction()843 void SurfaceFlinger::handleMessageTransaction() {
844 uint32_t transactionFlags = peekTransactionFlags(eTransactionMask);
845 if (transactionFlags) {
846 handleTransaction(transactionFlags);
847 }
848 }
849
handleMessageInvalidate()850 void SurfaceFlinger::handleMessageInvalidate() {
851 ATRACE_CALL();
852 handlePageFlip();
853 }
854
handleMessageRefresh()855 void SurfaceFlinger::handleMessageRefresh() {
856 ATRACE_CALL();
857 preComposition();
858 rebuildLayerStacks();
859 setUpHWComposer();
860 doDebugFlashRegions();
861 doComposition();
862 postComposition();
863 }
864
doDebugFlashRegions()865 void SurfaceFlinger::doDebugFlashRegions()
866 {
867 // is debugging enabled
868 if (CC_LIKELY(!mDebugRegion))
869 return;
870
871 const bool repaintEverything = mRepaintEverything;
872 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
873 const sp<DisplayDevice>& hw(mDisplays[dpy]);
874 if (hw->isDisplayOn()) {
875 // transform the dirty region into this screen's coordinate space
876 const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));
877 if (!dirtyRegion.isEmpty()) {
878 // redraw the whole screen
879 doComposeSurfaces(hw, Region(hw->bounds()));
880
881 // and draw the dirty region
882 const int32_t height = hw->getHeight();
883 RenderEngine& engine(getRenderEngine());
884 engine.fillRegionWithColor(dirtyRegion, height, 1, 0, 1, 1);
885
886 hw->compositionComplete();
887 hw->swapBuffers(getHwComposer());
888 }
889 }
890 }
891
892 postFramebuffer();
893
894 if (mDebugRegion > 1) {
895 usleep(mDebugRegion * 1000);
896 }
897
898 HWComposer& hwc(getHwComposer());
899 if (hwc.initCheck() == NO_ERROR) {
900 status_t err = hwc.prepare();
901 ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err));
902 }
903 }
904
preComposition()905 void SurfaceFlinger::preComposition()
906 {
907 bool needExtraInvalidate = false;
908 const LayerVector& layers(mDrawingState.layersSortedByZ);
909 const size_t count = layers.size();
910 for (size_t i=0 ; i<count ; i++) {
911 if (layers[i]->onPreComposition()) {
912 needExtraInvalidate = true;
913 }
914 }
915 if (needExtraInvalidate) {
916 signalLayerUpdate();
917 }
918 }
919
postComposition()920 void SurfaceFlinger::postComposition()
921 {
922 const LayerVector& layers(mDrawingState.layersSortedByZ);
923 const size_t count = layers.size();
924 for (size_t i=0 ; i<count ; i++) {
925 layers[i]->onPostComposition();
926 }
927
928 const HWComposer& hwc = getHwComposer();
929 sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY);
930
931 if (presentFence->isValid()) {
932 if (mPrimaryDispSync.addPresentFence(presentFence)) {
933 enableHardwareVsync();
934 } else {
935 disableHardwareVsync(false);
936 }
937 }
938
939 if (kIgnorePresentFences) {
940 const sp<const DisplayDevice> hw(getDefaultDisplayDevice());
941 if (hw->isDisplayOn()) {
942 enableHardwareVsync();
943 }
944 }
945
946 if (mAnimCompositionPending) {
947 mAnimCompositionPending = false;
948
949 if (presentFence->isValid()) {
950 mAnimFrameTracker.setActualPresentFence(presentFence);
951 } else {
952 // The HWC doesn't support present fences, so use the refresh
953 // timestamp instead.
954 nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY);
955 mAnimFrameTracker.setActualPresentTime(presentTime);
956 }
957 mAnimFrameTracker.advanceFrame();
958 }
959 }
960
rebuildLayerStacks()961 void SurfaceFlinger::rebuildLayerStacks() {
962 // rebuild the visible layer list per screen
963 if (CC_UNLIKELY(mVisibleRegionsDirty)) {
964 ATRACE_CALL();
965 mVisibleRegionsDirty = false;
966 invalidateHwcGeometry();
967
968 const LayerVector& layers(mDrawingState.layersSortedByZ);
969 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
970 Region opaqueRegion;
971 Region dirtyRegion;
972 Vector< sp<Layer> > layersSortedByZ;
973 const sp<DisplayDevice>& hw(mDisplays[dpy]);
974 const Transform& tr(hw->getTransform());
975 const Rect bounds(hw->getBounds());
976 if (hw->isDisplayOn()) {
977 SurfaceFlinger::computeVisibleRegions(layers,
978 hw->getLayerStack(), dirtyRegion, opaqueRegion);
979
980 const size_t count = layers.size();
981 for (size_t i=0 ; i<count ; i++) {
982 const sp<Layer>& layer(layers[i]);
983 const Layer::State& s(layer->getDrawingState());
984 if (s.layerStack == hw->getLayerStack()) {
985 Region drawRegion(tr.transform(
986 layer->visibleNonTransparentRegion));
987 drawRegion.andSelf(bounds);
988 if (!drawRegion.isEmpty()) {
989 layersSortedByZ.add(layer);
990 }
991 }
992 }
993 }
994 hw->setVisibleLayersSortedByZ(layersSortedByZ);
995 hw->undefinedRegion.set(bounds);
996 hw->undefinedRegion.subtractSelf(tr.transform(opaqueRegion));
997 hw->dirtyRegion.orSelf(dirtyRegion);
998 }
999 }
1000 }
1001
setUpHWComposer()1002 void SurfaceFlinger::setUpHWComposer() {
1003 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1004 bool dirty = !mDisplays[dpy]->getDirtyRegion(false).isEmpty();
1005 bool empty = mDisplays[dpy]->getVisibleLayersSortedByZ().size() == 0;
1006 bool wasEmpty = !mDisplays[dpy]->lastCompositionHadVisibleLayers;
1007
1008 // If nothing has changed (!dirty), don't recompose.
1009 // If something changed, but we don't currently have any visible layers,
1010 // and didn't when we last did a composition, then skip it this time.
1011 // The second rule does two things:
1012 // - When all layers are removed from a display, we'll emit one black
1013 // frame, then nothing more until we get new layers.
1014 // - When a display is created with a private layer stack, we won't
1015 // emit any black frames until a layer is added to the layer stack.
1016 bool mustRecompose = dirty && !(empty && wasEmpty);
1017
1018 ALOGV_IF(mDisplays[dpy]->getDisplayType() == DisplayDevice::DISPLAY_VIRTUAL,
1019 "dpy[%zu]: %s composition (%sdirty %sempty %swasEmpty)", dpy,
1020 mustRecompose ? "doing" : "skipping",
1021 dirty ? "+" : "-",
1022 empty ? "+" : "-",
1023 wasEmpty ? "+" : "-");
1024
1025 mDisplays[dpy]->beginFrame(mustRecompose);
1026
1027 if (mustRecompose) {
1028 mDisplays[dpy]->lastCompositionHadVisibleLayers = !empty;
1029 }
1030 }
1031
1032 HWComposer& hwc(getHwComposer());
1033 if (hwc.initCheck() == NO_ERROR) {
1034 // build the h/w work list
1035 if (CC_UNLIKELY(mHwWorkListDirty)) {
1036 mHwWorkListDirty = false;
1037 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1038 sp<const DisplayDevice> hw(mDisplays[dpy]);
1039 const int32_t id = hw->getHwcDisplayId();
1040 if (id >= 0) {
1041 const Vector< sp<Layer> >& currentLayers(
1042 hw->getVisibleLayersSortedByZ());
1043 const size_t count = currentLayers.size();
1044 if (hwc.createWorkList(id, count) == NO_ERROR) {
1045 HWComposer::LayerListIterator cur = hwc.begin(id);
1046 const HWComposer::LayerListIterator end = hwc.end(id);
1047 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1048 const sp<Layer>& layer(currentLayers[i]);
1049 layer->setGeometry(hw, *cur);
1050 if (mDebugDisableHWC || mDebugRegion || mDaltonize || mHasColorMatrix) {
1051 cur->setSkip(true);
1052 }
1053 }
1054 }
1055 }
1056 }
1057 }
1058
1059 // set the per-frame data
1060 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1061 sp<const DisplayDevice> hw(mDisplays[dpy]);
1062 const int32_t id = hw->getHwcDisplayId();
1063 if (id >= 0) {
1064 const Vector< sp<Layer> >& currentLayers(
1065 hw->getVisibleLayersSortedByZ());
1066 const size_t count = currentLayers.size();
1067 HWComposer::LayerListIterator cur = hwc.begin(id);
1068 const HWComposer::LayerListIterator end = hwc.end(id);
1069 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1070 /*
1071 * update the per-frame h/w composer data for each layer
1072 * and build the transparent region of the FB
1073 */
1074 const sp<Layer>& layer(currentLayers[i]);
1075 layer->setPerFrameData(hw, *cur);
1076 }
1077 }
1078 }
1079
1080 // If possible, attempt to use the cursor overlay on each display.
1081 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1082 sp<const DisplayDevice> hw(mDisplays[dpy]);
1083 const int32_t id = hw->getHwcDisplayId();
1084 if (id >= 0) {
1085 const Vector< sp<Layer> >& currentLayers(
1086 hw->getVisibleLayersSortedByZ());
1087 const size_t count = currentLayers.size();
1088 HWComposer::LayerListIterator cur = hwc.begin(id);
1089 const HWComposer::LayerListIterator end = hwc.end(id);
1090 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1091 const sp<Layer>& layer(currentLayers[i]);
1092 if (layer->isPotentialCursor()) {
1093 cur->setIsCursorLayerHint();
1094 break;
1095 }
1096 }
1097 }
1098 }
1099
1100 status_t err = hwc.prepare();
1101 ALOGE_IF(err, "HWComposer::prepare failed (%s)", strerror(-err));
1102
1103 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1104 sp<const DisplayDevice> hw(mDisplays[dpy]);
1105 hw->prepareFrame(hwc);
1106 }
1107 }
1108 }
1109
doComposition()1110 void SurfaceFlinger::doComposition() {
1111 ATRACE_CALL();
1112 const bool repaintEverything = android_atomic_and(0, &mRepaintEverything);
1113 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1114 const sp<DisplayDevice>& hw(mDisplays[dpy]);
1115 if (hw->isDisplayOn()) {
1116 // transform the dirty region into this screen's coordinate space
1117 const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));
1118
1119 // repaint the framebuffer (if needed)
1120 doDisplayComposition(hw, dirtyRegion);
1121
1122 hw->dirtyRegion.clear();
1123 hw->flip(hw->swapRegion);
1124 hw->swapRegion.clear();
1125 }
1126 // inform the h/w that we're done compositing
1127 hw->compositionComplete();
1128 }
1129 postFramebuffer();
1130 }
1131
postFramebuffer()1132 void SurfaceFlinger::postFramebuffer()
1133 {
1134 ATRACE_CALL();
1135
1136 const nsecs_t now = systemTime();
1137 mDebugInSwapBuffers = now;
1138
1139 HWComposer& hwc(getHwComposer());
1140 if (hwc.initCheck() == NO_ERROR) {
1141 if (!hwc.supportsFramebufferTarget()) {
1142 // EGL spec says:
1143 // "surface must be bound to the calling thread's current context,
1144 // for the current rendering API."
1145 getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
1146 }
1147 hwc.commit();
1148 }
1149
1150 // make the default display current because the VirtualDisplayDevice code cannot
1151 // deal with dequeueBuffer() being called outside of the composition loop; however
1152 // the code below can call glFlush() which is allowed (and does in some case) call
1153 // dequeueBuffer().
1154 getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
1155
1156 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1157 sp<const DisplayDevice> hw(mDisplays[dpy]);
1158 const Vector< sp<Layer> >& currentLayers(hw->getVisibleLayersSortedByZ());
1159 hw->onSwapBuffersCompleted(hwc);
1160 const size_t count = currentLayers.size();
1161 int32_t id = hw->getHwcDisplayId();
1162 if (id >=0 && hwc.initCheck() == NO_ERROR) {
1163 HWComposer::LayerListIterator cur = hwc.begin(id);
1164 const HWComposer::LayerListIterator end = hwc.end(id);
1165 for (size_t i = 0; cur != end && i < count; ++i, ++cur) {
1166 currentLayers[i]->onLayerDisplayed(hw, &*cur);
1167 }
1168 } else {
1169 for (size_t i = 0; i < count; i++) {
1170 currentLayers[i]->onLayerDisplayed(hw, NULL);
1171 }
1172 }
1173 }
1174
1175 mLastSwapBufferTime = systemTime() - now;
1176 mDebugInSwapBuffers = 0;
1177
1178 uint32_t flipCount = getDefaultDisplayDevice()->getPageFlipCount();
1179 if (flipCount % LOG_FRAME_STATS_PERIOD == 0) {
1180 logFrameStats();
1181 }
1182 }
1183
handleTransaction(uint32_t transactionFlags)1184 void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
1185 {
1186 ATRACE_CALL();
1187
1188 // here we keep a copy of the drawing state (that is the state that's
1189 // going to be overwritten by handleTransactionLocked()) outside of
1190 // mStateLock so that the side-effects of the State assignment
1191 // don't happen with mStateLock held (which can cause deadlocks).
1192 State drawingState(mDrawingState);
1193
1194 Mutex::Autolock _l(mStateLock);
1195 const nsecs_t now = systemTime();
1196 mDebugInTransaction = now;
1197
1198 // Here we're guaranteed that some transaction flags are set
1199 // so we can call handleTransactionLocked() unconditionally.
1200 // We call getTransactionFlags(), which will also clear the flags,
1201 // with mStateLock held to guarantee that mCurrentState won't change
1202 // until the transaction is committed.
1203
1204 transactionFlags = getTransactionFlags(eTransactionMask);
1205 handleTransactionLocked(transactionFlags);
1206
1207 mLastTransactionTime = systemTime() - now;
1208 mDebugInTransaction = 0;
1209 invalidateHwcGeometry();
1210 // here the transaction has been committed
1211 }
1212
handleTransactionLocked(uint32_t transactionFlags)1213 void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
1214 {
1215 const LayerVector& currentLayers(mCurrentState.layersSortedByZ);
1216 const size_t count = currentLayers.size();
1217
1218 /*
1219 * Traversal of the children
1220 * (perform the transaction for each of them if needed)
1221 */
1222
1223 if (transactionFlags & eTraversalNeeded) {
1224 for (size_t i=0 ; i<count ; i++) {
1225 const sp<Layer>& layer(currentLayers[i]);
1226 uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
1227 if (!trFlags) continue;
1228
1229 const uint32_t flags = layer->doTransaction(0);
1230 if (flags & Layer::eVisibleRegion)
1231 mVisibleRegionsDirty = true;
1232 }
1233 }
1234
1235 /*
1236 * Perform display own transactions if needed
1237 */
1238
1239 if (transactionFlags & eDisplayTransactionNeeded) {
1240 // here we take advantage of Vector's copy-on-write semantics to
1241 // improve performance by skipping the transaction entirely when
1242 // know that the lists are identical
1243 const KeyedVector< wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
1244 const KeyedVector< wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);
1245 if (!curr.isIdenticalTo(draw)) {
1246 mVisibleRegionsDirty = true;
1247 const size_t cc = curr.size();
1248 size_t dc = draw.size();
1249
1250 // find the displays that were removed
1251 // (ie: in drawing state but not in current state)
1252 // also handle displays that changed
1253 // (ie: displays that are in both lists)
1254 for (size_t i=0 ; i<dc ; i++) {
1255 const ssize_t j = curr.indexOfKey(draw.keyAt(i));
1256 if (j < 0) {
1257 // in drawing state but not in current state
1258 if (!draw[i].isMainDisplay()) {
1259 // Call makeCurrent() on the primary display so we can
1260 // be sure that nothing associated with this display
1261 // is current.
1262 const sp<const DisplayDevice> defaultDisplay(getDefaultDisplayDevice());
1263 defaultDisplay->makeCurrent(mEGLDisplay, mEGLContext);
1264 sp<DisplayDevice> hw(getDisplayDevice(draw.keyAt(i)));
1265 if (hw != NULL)
1266 hw->disconnect(getHwComposer());
1267 if (draw[i].type < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES)
1268 mEventThread->onHotplugReceived(draw[i].type, false);
1269 mDisplays.removeItem(draw.keyAt(i));
1270 } else {
1271 ALOGW("trying to remove the main display");
1272 }
1273 } else {
1274 // this display is in both lists. see if something changed.
1275 const DisplayDeviceState& state(curr[j]);
1276 const wp<IBinder>& display(curr.keyAt(j));
1277 if (state.surface->asBinder() != draw[i].surface->asBinder()) {
1278 // changing the surface is like destroying and
1279 // recreating the DisplayDevice, so we just remove it
1280 // from the drawing state, so that it get re-added
1281 // below.
1282 sp<DisplayDevice> hw(getDisplayDevice(display));
1283 if (hw != NULL)
1284 hw->disconnect(getHwComposer());
1285 mDisplays.removeItem(display);
1286 mDrawingState.displays.removeItemsAt(i);
1287 dc--; i--;
1288 // at this point we must loop to the next item
1289 continue;
1290 }
1291
1292 const sp<DisplayDevice> disp(getDisplayDevice(display));
1293 if (disp != NULL) {
1294 if (state.layerStack != draw[i].layerStack) {
1295 disp->setLayerStack(state.layerStack);
1296 }
1297 if ((state.orientation != draw[i].orientation)
1298 || (state.viewport != draw[i].viewport)
1299 || (state.frame != draw[i].frame))
1300 {
1301 disp->setProjection(state.orientation,
1302 state.viewport, state.frame);
1303 }
1304 if (state.width != draw[i].width || state.height != draw[i].height) {
1305 disp->setDisplaySize(state.width, state.height);
1306 }
1307 }
1308 }
1309 }
1310
1311 // find displays that were added
1312 // (ie: in current state but not in drawing state)
1313 for (size_t i=0 ; i<cc ; i++) {
1314 if (draw.indexOfKey(curr.keyAt(i)) < 0) {
1315 const DisplayDeviceState& state(curr[i]);
1316
1317 sp<DisplaySurface> dispSurface;
1318 sp<IGraphicBufferProducer> producer;
1319 sp<IGraphicBufferProducer> bqProducer;
1320 sp<IGraphicBufferConsumer> bqConsumer;
1321 BufferQueue::createBufferQueue(&bqProducer, &bqConsumer,
1322 new GraphicBufferAlloc());
1323
1324 int32_t hwcDisplayId = -1;
1325 if (state.isVirtualDisplay()) {
1326 // Virtual displays without a surface are dormant:
1327 // they have external state (layer stack, projection,
1328 // etc.) but no internal state (i.e. a DisplayDevice).
1329 if (state.surface != NULL) {
1330
1331 hwcDisplayId = allocateHwcDisplayId(state.type);
1332 sp<VirtualDisplaySurface> vds = new VirtualDisplaySurface(
1333 *mHwc, hwcDisplayId, state.surface,
1334 bqProducer, bqConsumer, state.displayName);
1335
1336 dispSurface = vds;
1337 producer = vds;
1338 }
1339 } else {
1340 ALOGE_IF(state.surface!=NULL,
1341 "adding a supported display, but rendering "
1342 "surface is provided (%p), ignoring it",
1343 state.surface.get());
1344 hwcDisplayId = allocateHwcDisplayId(state.type);
1345 // for supported (by hwc) displays we provide our
1346 // own rendering surface
1347 dispSurface = new FramebufferSurface(*mHwc, state.type,
1348 bqConsumer);
1349 producer = bqProducer;
1350 }
1351
1352 const wp<IBinder>& display(curr.keyAt(i));
1353 if (dispSurface != NULL) {
1354 sp<DisplayDevice> hw = new DisplayDevice(this,
1355 state.type, hwcDisplayId,
1356 mHwc->getFormat(hwcDisplayId), state.isSecure,
1357 display, dispSurface, producer,
1358 mRenderEngine->getEGLConfig());
1359 hw->setLayerStack(state.layerStack);
1360 hw->setProjection(state.orientation,
1361 state.viewport, state.frame);
1362 hw->setDisplayName(state.displayName);
1363 mDisplays.add(display, hw);
1364 if (state.isVirtualDisplay()) {
1365 if (hwcDisplayId >= 0) {
1366 mHwc->setVirtualDisplayProperties(hwcDisplayId,
1367 hw->getWidth(), hw->getHeight(),
1368 hw->getFormat());
1369 }
1370 } else {
1371 mEventThread->onHotplugReceived(state.type, true);
1372 }
1373 }
1374 }
1375 }
1376 }
1377 }
1378
1379 if (transactionFlags & (eTraversalNeeded|eDisplayTransactionNeeded)) {
1380 // The transform hint might have changed for some layers
1381 // (either because a display has changed, or because a layer
1382 // as changed).
1383 //
1384 // Walk through all the layers in currentLayers,
1385 // and update their transform hint.
1386 //
1387 // If a layer is visible only on a single display, then that
1388 // display is used to calculate the hint, otherwise we use the
1389 // default display.
1390 //
1391 // NOTE: we do this here, rather than in rebuildLayerStacks() so that
1392 // the hint is set before we acquire a buffer from the surface texture.
1393 //
1394 // NOTE: layer transactions have taken place already, so we use their
1395 // drawing state. However, SurfaceFlinger's own transaction has not
1396 // happened yet, so we must use the current state layer list
1397 // (soon to become the drawing state list).
1398 //
1399 sp<const DisplayDevice> disp;
1400 uint32_t currentlayerStack = 0;
1401 for (size_t i=0; i<count; i++) {
1402 // NOTE: we rely on the fact that layers are sorted by
1403 // layerStack first (so we don't have to traverse the list
1404 // of displays for every layer).
1405 const sp<Layer>& layer(currentLayers[i]);
1406 uint32_t layerStack = layer->getDrawingState().layerStack;
1407 if (i==0 || currentlayerStack != layerStack) {
1408 currentlayerStack = layerStack;
1409 // figure out if this layerstack is mirrored
1410 // (more than one display) if so, pick the default display,
1411 // if not, pick the only display it's on.
1412 disp.clear();
1413 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1414 sp<const DisplayDevice> hw(mDisplays[dpy]);
1415 if (hw->getLayerStack() == currentlayerStack) {
1416 if (disp == NULL) {
1417 disp = hw;
1418 } else {
1419 disp = NULL;
1420 break;
1421 }
1422 }
1423 }
1424 }
1425 if (disp == NULL) {
1426 // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to
1427 // redraw after transform hint changes. See bug 8508397.
1428
1429 // could be null when this layer is using a layerStack
1430 // that is not visible on any display. Also can occur at
1431 // screen off/on times.
1432 disp = getDefaultDisplayDevice();
1433 }
1434 layer->updateTransformHint(disp);
1435 }
1436 }
1437
1438
1439 /*
1440 * Perform our own transaction if needed
1441 */
1442
1443 const LayerVector& layers(mDrawingState.layersSortedByZ);
1444 if (currentLayers.size() > layers.size()) {
1445 // layers have been added
1446 mVisibleRegionsDirty = true;
1447 }
1448
1449 // some layers might have been removed, so
1450 // we need to update the regions they're exposing.
1451 if (mLayersRemoved) {
1452 mLayersRemoved = false;
1453 mVisibleRegionsDirty = true;
1454 const size_t count = layers.size();
1455 for (size_t i=0 ; i<count ; i++) {
1456 const sp<Layer>& layer(layers[i]);
1457 if (currentLayers.indexOf(layer) < 0) {
1458 // this layer is not visible anymore
1459 // TODO: we could traverse the tree from front to back and
1460 // compute the actual visible region
1461 // TODO: we could cache the transformed region
1462 const Layer::State& s(layer->getDrawingState());
1463 Region visibleReg = s.transform.transform(
1464 Region(Rect(s.active.w, s.active.h)));
1465 invalidateLayerStack(s.layerStack, visibleReg);
1466 }
1467 }
1468 }
1469
1470 commitTransaction();
1471
1472 updateCursorAsync();
1473 }
1474
updateCursorAsync()1475 void SurfaceFlinger::updateCursorAsync()
1476 {
1477 HWComposer& hwc(getHwComposer());
1478 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1479 sp<const DisplayDevice> hw(mDisplays[dpy]);
1480 const int32_t id = hw->getHwcDisplayId();
1481 if (id < 0) {
1482 continue;
1483 }
1484 const Vector< sp<Layer> >& currentLayers(
1485 hw->getVisibleLayersSortedByZ());
1486 const size_t count = currentLayers.size();
1487 HWComposer::LayerListIterator cur = hwc.begin(id);
1488 const HWComposer::LayerListIterator end = hwc.end(id);
1489 for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
1490 if (cur->getCompositionType() != HWC_CURSOR_OVERLAY) {
1491 continue;
1492 }
1493 const sp<Layer>& layer(currentLayers[i]);
1494 Rect cursorPos = layer->getPosition(hw);
1495 hwc.setCursorPositionAsync(id, cursorPos);
1496 break;
1497 }
1498 }
1499 }
1500
commitTransaction()1501 void SurfaceFlinger::commitTransaction()
1502 {
1503 if (!mLayersPendingRemoval.isEmpty()) {
1504 // Notify removed layers now that they can't be drawn from
1505 for (size_t i = 0; i < mLayersPendingRemoval.size(); i++) {
1506 mLayersPendingRemoval[i]->onRemoved();
1507 }
1508 mLayersPendingRemoval.clear();
1509 }
1510
1511 // If this transaction is part of a window animation then the next frame
1512 // we composite should be considered an animation as well.
1513 mAnimCompositionPending = mAnimTransactionPending;
1514
1515 mDrawingState = mCurrentState;
1516 mTransactionPending = false;
1517 mAnimTransactionPending = false;
1518 mTransactionCV.broadcast();
1519 }
1520
computeVisibleRegions(const LayerVector & currentLayers,uint32_t layerStack,Region & outDirtyRegion,Region & outOpaqueRegion)1521 void SurfaceFlinger::computeVisibleRegions(
1522 const LayerVector& currentLayers, uint32_t layerStack,
1523 Region& outDirtyRegion, Region& outOpaqueRegion)
1524 {
1525 ATRACE_CALL();
1526
1527 Region aboveOpaqueLayers;
1528 Region aboveCoveredLayers;
1529 Region dirty;
1530
1531 outDirtyRegion.clear();
1532
1533 size_t i = currentLayers.size();
1534 while (i--) {
1535 const sp<Layer>& layer = currentLayers[i];
1536
1537 // start with the whole surface at its current location
1538 const Layer::State& s(layer->getDrawingState());
1539
1540 // only consider the layers on the given layer stack
1541 if (s.layerStack != layerStack)
1542 continue;
1543
1544 /*
1545 * opaqueRegion: area of a surface that is fully opaque.
1546 */
1547 Region opaqueRegion;
1548
1549 /*
1550 * visibleRegion: area of a surface that is visible on screen
1551 * and not fully transparent. This is essentially the layer's
1552 * footprint minus the opaque regions above it.
1553 * Areas covered by a translucent surface are considered visible.
1554 */
1555 Region visibleRegion;
1556
1557 /*
1558 * coveredRegion: area of a surface that is covered by all
1559 * visible regions above it (which includes the translucent areas).
1560 */
1561 Region coveredRegion;
1562
1563 /*
1564 * transparentRegion: area of a surface that is hinted to be completely
1565 * transparent. This is only used to tell when the layer has no visible
1566 * non-transparent regions and can be removed from the layer list. It
1567 * does not affect the visibleRegion of this layer or any layers
1568 * beneath it. The hint may not be correct if apps don't respect the
1569 * SurfaceView restrictions (which, sadly, some don't).
1570 */
1571 Region transparentRegion;
1572
1573
1574 // handle hidden surfaces by setting the visible region to empty
1575 if (CC_LIKELY(layer->isVisible())) {
1576 const bool translucent = !layer->isOpaque(s);
1577 Rect bounds(s.transform.transform(layer->computeBounds()));
1578 visibleRegion.set(bounds);
1579 if (!visibleRegion.isEmpty()) {
1580 // Remove the transparent area from the visible region
1581 if (translucent) {
1582 const Transform tr(s.transform);
1583 if (tr.transformed()) {
1584 if (tr.preserveRects()) {
1585 // transform the transparent region
1586 transparentRegion = tr.transform(s.activeTransparentRegion);
1587 } else {
1588 // transformation too complex, can't do the
1589 // transparent region optimization.
1590 transparentRegion.clear();
1591 }
1592 } else {
1593 transparentRegion = s.activeTransparentRegion;
1594 }
1595 }
1596
1597 // compute the opaque region
1598 const int32_t layerOrientation = s.transform.getOrientation();
1599 if (s.alpha==255 && !translucent &&
1600 ((layerOrientation & Transform::ROT_INVALID) == false)) {
1601 // the opaque region is the layer's footprint
1602 opaqueRegion = visibleRegion;
1603 }
1604 }
1605 }
1606
1607 // Clip the covered region to the visible region
1608 coveredRegion = aboveCoveredLayers.intersect(visibleRegion);
1609
1610 // Update aboveCoveredLayers for next (lower) layer
1611 aboveCoveredLayers.orSelf(visibleRegion);
1612
1613 // subtract the opaque region covered by the layers above us
1614 visibleRegion.subtractSelf(aboveOpaqueLayers);
1615
1616 // compute this layer's dirty region
1617 if (layer->contentDirty) {
1618 // we need to invalidate the whole region
1619 dirty = visibleRegion;
1620 // as well, as the old visible region
1621 dirty.orSelf(layer->visibleRegion);
1622 layer->contentDirty = false;
1623 } else {
1624 /* compute the exposed region:
1625 * the exposed region consists of two components:
1626 * 1) what's VISIBLE now and was COVERED before
1627 * 2) what's EXPOSED now less what was EXPOSED before
1628 *
1629 * note that (1) is conservative, we start with the whole
1630 * visible region but only keep what used to be covered by
1631 * something -- which mean it may have been exposed.
1632 *
1633 * (2) handles areas that were not covered by anything but got
1634 * exposed because of a resize.
1635 */
1636 const Region newExposed = visibleRegion - coveredRegion;
1637 const Region oldVisibleRegion = layer->visibleRegion;
1638 const Region oldCoveredRegion = layer->coveredRegion;
1639 const Region oldExposed = oldVisibleRegion - oldCoveredRegion;
1640 dirty = (visibleRegion&oldCoveredRegion) | (newExposed-oldExposed);
1641 }
1642 dirty.subtractSelf(aboveOpaqueLayers);
1643
1644 // accumulate to the screen dirty region
1645 outDirtyRegion.orSelf(dirty);
1646
1647 // Update aboveOpaqueLayers for next (lower) layer
1648 aboveOpaqueLayers.orSelf(opaqueRegion);
1649
1650 // Store the visible region in screen space
1651 layer->setVisibleRegion(visibleRegion);
1652 layer->setCoveredRegion(coveredRegion);
1653 layer->setVisibleNonTransparentRegion(
1654 visibleRegion.subtract(transparentRegion));
1655 }
1656
1657 outOpaqueRegion = aboveOpaqueLayers;
1658 }
1659
invalidateLayerStack(uint32_t layerStack,const Region & dirty)1660 void SurfaceFlinger::invalidateLayerStack(uint32_t layerStack,
1661 const Region& dirty) {
1662 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
1663 const sp<DisplayDevice>& hw(mDisplays[dpy]);
1664 if (hw->getLayerStack() == layerStack) {
1665 hw->dirtyRegion.orSelf(dirty);
1666 }
1667 }
1668 }
1669
handlePageFlip()1670 void SurfaceFlinger::handlePageFlip()
1671 {
1672 Region dirtyRegion;
1673
1674 bool visibleRegions = false;
1675 const LayerVector& layers(mDrawingState.layersSortedByZ);
1676
1677 // Store the set of layers that need updates. This set must not change as
1678 // buffers are being latched, as this could result in a deadlock.
1679 // Example: Two producers share the same command stream and:
1680 // 1.) Layer 0 is latched
1681 // 2.) Layer 0 gets a new frame
1682 // 2.) Layer 1 gets a new frame
1683 // 3.) Layer 1 is latched.
1684 // Display is now waiting on Layer 1's frame, which is behind layer 0's
1685 // second frame. But layer 0's second frame could be waiting on display.
1686 Vector<Layer*> layersWithQueuedFrames;
1687 for (size_t i = 0, count = layers.size(); i<count ; i++) {
1688 const sp<Layer>& layer(layers[i]);
1689 if (layer->hasQueuedFrame())
1690 layersWithQueuedFrames.push_back(layer.get());
1691 }
1692 for (size_t i = 0, count = layersWithQueuedFrames.size() ; i<count ; i++) {
1693 Layer* layer = layersWithQueuedFrames[i];
1694 const Region dirty(layer->latchBuffer(visibleRegions));
1695 const Layer::State& s(layer->getDrawingState());
1696 invalidateLayerStack(s.layerStack, dirty);
1697 }
1698
1699 mVisibleRegionsDirty |= visibleRegions;
1700 }
1701
invalidateHwcGeometry()1702 void SurfaceFlinger::invalidateHwcGeometry()
1703 {
1704 mHwWorkListDirty = true;
1705 }
1706
1707
doDisplayComposition(const sp<const DisplayDevice> & hw,const Region & inDirtyRegion)1708 void SurfaceFlinger::doDisplayComposition(const sp<const DisplayDevice>& hw,
1709 const Region& inDirtyRegion)
1710 {
1711 // We only need to actually compose the display if:
1712 // 1) It is being handled by hardware composer, which may need this to
1713 // keep its virtual display state machine in sync, or
1714 // 2) There is work to be done (the dirty region isn't empty)
1715 bool isHwcDisplay = hw->getHwcDisplayId() >= 0;
1716 if (!isHwcDisplay && inDirtyRegion.isEmpty()) {
1717 return;
1718 }
1719
1720 Region dirtyRegion(inDirtyRegion);
1721
1722 // compute the invalid region
1723 hw->swapRegion.orSelf(dirtyRegion);
1724
1725 uint32_t flags = hw->getFlags();
1726 if (flags & DisplayDevice::SWAP_RECTANGLE) {
1727 // we can redraw only what's dirty, but since SWAP_RECTANGLE only
1728 // takes a rectangle, we must make sure to update that whole
1729 // rectangle in that case
1730 dirtyRegion.set(hw->swapRegion.bounds());
1731 } else {
1732 if (flags & DisplayDevice::PARTIAL_UPDATES) {
1733 // We need to redraw the rectangle that will be updated
1734 // (pushed to the framebuffer).
1735 // This is needed because PARTIAL_UPDATES only takes one
1736 // rectangle instead of a region (see DisplayDevice::flip())
1737 dirtyRegion.set(hw->swapRegion.bounds());
1738 } else {
1739 // we need to redraw everything (the whole screen)
1740 dirtyRegion.set(hw->bounds());
1741 hw->swapRegion = dirtyRegion;
1742 }
1743 }
1744
1745 if (CC_LIKELY(!mDaltonize && !mHasColorMatrix)) {
1746 if (!doComposeSurfaces(hw, dirtyRegion)) return;
1747 } else {
1748 RenderEngine& engine(getRenderEngine());
1749 mat4 colorMatrix = mColorMatrix;
1750 if (mDaltonize) {
1751 colorMatrix = colorMatrix * mDaltonizer();
1752 }
1753 engine.beginGroup(colorMatrix);
1754 doComposeSurfaces(hw, dirtyRegion);
1755 engine.endGroup();
1756 }
1757
1758 // update the swap region and clear the dirty region
1759 hw->swapRegion.orSelf(dirtyRegion);
1760
1761 // swap buffers (presentation)
1762 hw->swapBuffers(getHwComposer());
1763 }
1764
doComposeSurfaces(const sp<const DisplayDevice> & hw,const Region & dirty)1765 bool SurfaceFlinger::doComposeSurfaces(const sp<const DisplayDevice>& hw, const Region& dirty)
1766 {
1767 RenderEngine& engine(getRenderEngine());
1768 const int32_t id = hw->getHwcDisplayId();
1769 HWComposer& hwc(getHwComposer());
1770 HWComposer::LayerListIterator cur = hwc.begin(id);
1771 const HWComposer::LayerListIterator end = hwc.end(id);
1772
1773 bool hasGlesComposition = hwc.hasGlesComposition(id);
1774 if (hasGlesComposition) {
1775 if (!hw->makeCurrent(mEGLDisplay, mEGLContext)) {
1776 ALOGW("DisplayDevice::makeCurrent failed. Aborting surface composition for display %s",
1777 hw->getDisplayName().string());
1778 eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
1779 if(!getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext)) {
1780 ALOGE("DisplayDevice::makeCurrent on default display failed. Aborting.");
1781 }
1782 return false;
1783 }
1784
1785 // Never touch the framebuffer if we don't have any framebuffer layers
1786 const bool hasHwcComposition = hwc.hasHwcComposition(id);
1787 if (hasHwcComposition) {
1788 // when using overlays, we assume a fully transparent framebuffer
1789 // NOTE: we could reduce how much we need to clear, for instance
1790 // remove where there are opaque FB layers. however, on some
1791 // GPUs doing a "clean slate" clear might be more efficient.
1792 // We'll revisit later if needed.
1793 engine.clearWithColor(0, 0, 0, 0);
1794 } else {
1795 // we start with the whole screen area
1796 const Region bounds(hw->getBounds());
1797
1798 // we remove the scissor part
1799 // we're left with the letterbox region
1800 // (common case is that letterbox ends-up being empty)
1801 const Region letterbox(bounds.subtract(hw->getScissor()));
1802
1803 // compute the area to clear
1804 Region region(hw->undefinedRegion.merge(letterbox));
1805
1806 // but limit it to the dirty region
1807 region.andSelf(dirty);
1808
1809 // screen is already cleared here
1810 if (!region.isEmpty()) {
1811 // can happen with SurfaceView
1812 drawWormhole(hw, region);
1813 }
1814 }
1815
1816 if (hw->getDisplayType() != DisplayDevice::DISPLAY_PRIMARY) {
1817 // just to be on the safe side, we don't set the
1818 // scissor on the main display. It should never be needed
1819 // anyways (though in theory it could since the API allows it).
1820 const Rect& bounds(hw->getBounds());
1821 const Rect& scissor(hw->getScissor());
1822 if (scissor != bounds) {
1823 // scissor doesn't match the screen's dimensions, so we
1824 // need to clear everything outside of it and enable
1825 // the GL scissor so we don't draw anything where we shouldn't
1826
1827 // enable scissor for this frame
1828 const uint32_t height = hw->getHeight();
1829 engine.setScissor(scissor.left, height - scissor.bottom,
1830 scissor.getWidth(), scissor.getHeight());
1831 }
1832 }
1833 }
1834
1835 /*
1836 * and then, render the layers targeted at the framebuffer
1837 */
1838
1839 const Vector< sp<Layer> >& layers(hw->getVisibleLayersSortedByZ());
1840 const size_t count = layers.size();
1841 const Transform& tr = hw->getTransform();
1842 if (cur != end) {
1843 // we're using h/w composer
1844 for (size_t i=0 ; i<count && cur!=end ; ++i, ++cur) {
1845 const sp<Layer>& layer(layers[i]);
1846 const Region clip(dirty.intersect(tr.transform(layer->visibleRegion)));
1847 if (!clip.isEmpty()) {
1848 switch (cur->getCompositionType()) {
1849 case HWC_CURSOR_OVERLAY:
1850 case HWC_OVERLAY: {
1851 const Layer::State& state(layer->getDrawingState());
1852 if ((cur->getHints() & HWC_HINT_CLEAR_FB)
1853 && i
1854 && layer->isOpaque(state) && (state.alpha == 0xFF)
1855 && hasGlesComposition) {
1856 // never clear the very first layer since we're
1857 // guaranteed the FB is already cleared
1858 layer->clearWithOpenGL(hw, clip);
1859 }
1860 break;
1861 }
1862 case HWC_FRAMEBUFFER: {
1863 layer->draw(hw, clip);
1864 break;
1865 }
1866 case HWC_FRAMEBUFFER_TARGET: {
1867 // this should not happen as the iterator shouldn't
1868 // let us get there.
1869 ALOGW("HWC_FRAMEBUFFER_TARGET found in hwc list (index=%zu)", i);
1870 break;
1871 }
1872 }
1873 }
1874 layer->setAcquireFence(hw, *cur);
1875 }
1876 } else {
1877 // we're not using h/w composer
1878 for (size_t i=0 ; i<count ; ++i) {
1879 const sp<Layer>& layer(layers[i]);
1880 const Region clip(dirty.intersect(
1881 tr.transform(layer->visibleRegion)));
1882 if (!clip.isEmpty()) {
1883 layer->draw(hw, clip);
1884 }
1885 }
1886 }
1887
1888 // disable scissor at the end of the frame
1889 engine.disableScissor();
1890 return true;
1891 }
1892
drawWormhole(const sp<const DisplayDevice> & hw,const Region & region) const1893 void SurfaceFlinger::drawWormhole(const sp<const DisplayDevice>& hw, const Region& region) const {
1894 const int32_t height = hw->getHeight();
1895 RenderEngine& engine(getRenderEngine());
1896 engine.fillRegionWithColor(region, height, 0, 0, 0, 0);
1897 }
1898
addClientLayer(const sp<Client> & client,const sp<IBinder> & handle,const sp<IGraphicBufferProducer> & gbc,const sp<Layer> & lbc)1899 void SurfaceFlinger::addClientLayer(const sp<Client>& client,
1900 const sp<IBinder>& handle,
1901 const sp<IGraphicBufferProducer>& gbc,
1902 const sp<Layer>& lbc)
1903 {
1904 // attach this layer to the client
1905 client->attachLayer(handle, lbc);
1906
1907 // add this layer to the current state list
1908 Mutex::Autolock _l(mStateLock);
1909 mCurrentState.layersSortedByZ.add(lbc);
1910 mGraphicBufferProducerList.add(gbc->asBinder());
1911 }
1912
removeLayer(const sp<Layer> & layer)1913 status_t SurfaceFlinger::removeLayer(const sp<Layer>& layer) {
1914 Mutex::Autolock _l(mStateLock);
1915 ssize_t index = mCurrentState.layersSortedByZ.remove(layer);
1916 if (index >= 0) {
1917 mLayersPendingRemoval.push(layer);
1918 mLayersRemoved = true;
1919 setTransactionFlags(eTransactionNeeded);
1920 return NO_ERROR;
1921 }
1922 return status_t(index);
1923 }
1924
peekTransactionFlags(uint32_t)1925 uint32_t SurfaceFlinger::peekTransactionFlags(uint32_t /* flags */) {
1926 return android_atomic_release_load(&mTransactionFlags);
1927 }
1928
getTransactionFlags(uint32_t flags)1929 uint32_t SurfaceFlinger::getTransactionFlags(uint32_t flags) {
1930 return android_atomic_and(~flags, &mTransactionFlags) & flags;
1931 }
1932
setTransactionFlags(uint32_t flags)1933 uint32_t SurfaceFlinger::setTransactionFlags(uint32_t flags) {
1934 uint32_t old = android_atomic_or(flags, &mTransactionFlags);
1935 if ((old & flags)==0) { // wake the server up
1936 signalTransaction();
1937 }
1938 return old;
1939 }
1940
setTransactionState(const Vector<ComposerState> & state,const Vector<DisplayState> & displays,uint32_t flags)1941 void SurfaceFlinger::setTransactionState(
1942 const Vector<ComposerState>& state,
1943 const Vector<DisplayState>& displays,
1944 uint32_t flags)
1945 {
1946 ATRACE_CALL();
1947 Mutex::Autolock _l(mStateLock);
1948 uint32_t transactionFlags = 0;
1949
1950 if (flags & eAnimation) {
1951 // For window updates that are part of an animation we must wait for
1952 // previous animation "frames" to be handled.
1953 while (mAnimTransactionPending) {
1954 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
1955 if (CC_UNLIKELY(err != NO_ERROR)) {
1956 // just in case something goes wrong in SF, return to the
1957 // caller after a few seconds.
1958 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out "
1959 "waiting for previous animation frame");
1960 mAnimTransactionPending = false;
1961 break;
1962 }
1963 }
1964 }
1965
1966 size_t count = displays.size();
1967 for (size_t i=0 ; i<count ; i++) {
1968 const DisplayState& s(displays[i]);
1969 transactionFlags |= setDisplayStateLocked(s);
1970 }
1971
1972 count = state.size();
1973 for (size_t i=0 ; i<count ; i++) {
1974 const ComposerState& s(state[i]);
1975 // Here we need to check that the interface we're given is indeed
1976 // one of our own. A malicious client could give us a NULL
1977 // IInterface, or one of its own or even one of our own but a
1978 // different type. All these situations would cause us to crash.
1979 //
1980 // NOTE: it would be better to use RTTI as we could directly check
1981 // that we have a Client*. however, RTTI is disabled in Android.
1982 if (s.client != NULL) {
1983 sp<IBinder> binder = s.client->asBinder();
1984 if (binder != NULL) {
1985 String16 desc(binder->getInterfaceDescriptor());
1986 if (desc == ISurfaceComposerClient::descriptor) {
1987 sp<Client> client( static_cast<Client *>(s.client.get()) );
1988 transactionFlags |= setClientStateLocked(client, s.state);
1989 }
1990 }
1991 }
1992 }
1993
1994 if (transactionFlags) {
1995 // this triggers the transaction
1996 setTransactionFlags(transactionFlags);
1997
1998 // if this is a synchronous transaction, wait for it to take effect
1999 // before returning.
2000 if (flags & eSynchronous) {
2001 mTransactionPending = true;
2002 }
2003 if (flags & eAnimation) {
2004 mAnimTransactionPending = true;
2005 }
2006 while (mTransactionPending) {
2007 status_t err = mTransactionCV.waitRelative(mStateLock, s2ns(5));
2008 if (CC_UNLIKELY(err != NO_ERROR)) {
2009 // just in case something goes wrong in SF, return to the
2010 // called after a few seconds.
2011 ALOGW_IF(err == TIMED_OUT, "setTransactionState timed out!");
2012 mTransactionPending = false;
2013 break;
2014 }
2015 }
2016 }
2017 }
2018
setDisplayStateLocked(const DisplayState & s)2019 uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s)
2020 {
2021 ssize_t dpyIdx = mCurrentState.displays.indexOfKey(s.token);
2022 if (dpyIdx < 0)
2023 return 0;
2024
2025 uint32_t flags = 0;
2026 DisplayDeviceState& disp(mCurrentState.displays.editValueAt(dpyIdx));
2027 if (disp.isValid()) {
2028 const uint32_t what = s.what;
2029 if (what & DisplayState::eSurfaceChanged) {
2030 if (disp.surface->asBinder() != s.surface->asBinder()) {
2031 disp.surface = s.surface;
2032 flags |= eDisplayTransactionNeeded;
2033 }
2034 }
2035 if (what & DisplayState::eLayerStackChanged) {
2036 if (disp.layerStack != s.layerStack) {
2037 disp.layerStack = s.layerStack;
2038 flags |= eDisplayTransactionNeeded;
2039 }
2040 }
2041 if (what & DisplayState::eDisplayProjectionChanged) {
2042 if (disp.orientation != s.orientation) {
2043 disp.orientation = s.orientation;
2044 flags |= eDisplayTransactionNeeded;
2045 }
2046 if (disp.frame != s.frame) {
2047 disp.frame = s.frame;
2048 flags |= eDisplayTransactionNeeded;
2049 }
2050 if (disp.viewport != s.viewport) {
2051 disp.viewport = s.viewport;
2052 flags |= eDisplayTransactionNeeded;
2053 }
2054 }
2055 if (what & DisplayState::eDisplaySizeChanged) {
2056 if (disp.width != s.width) {
2057 disp.width = s.width;
2058 flags |= eDisplayTransactionNeeded;
2059 }
2060 if (disp.height != s.height) {
2061 disp.height = s.height;
2062 flags |= eDisplayTransactionNeeded;
2063 }
2064 }
2065 }
2066 return flags;
2067 }
2068
setClientStateLocked(const sp<Client> & client,const layer_state_t & s)2069 uint32_t SurfaceFlinger::setClientStateLocked(
2070 const sp<Client>& client,
2071 const layer_state_t& s)
2072 {
2073 uint32_t flags = 0;
2074 sp<Layer> layer(client->getLayerUser(s.surface));
2075 if (layer != 0) {
2076 const uint32_t what = s.what;
2077 if (what & layer_state_t::ePositionChanged) {
2078 if (layer->setPosition(s.x, s.y))
2079 flags |= eTraversalNeeded;
2080 }
2081 if (what & layer_state_t::eLayerChanged) {
2082 // NOTE: index needs to be calculated before we update the state
2083 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
2084 if (layer->setLayer(s.z)) {
2085 mCurrentState.layersSortedByZ.removeAt(idx);
2086 mCurrentState.layersSortedByZ.add(layer);
2087 // we need traversal (state changed)
2088 // AND transaction (list changed)
2089 flags |= eTransactionNeeded|eTraversalNeeded;
2090 }
2091 }
2092 if (what & layer_state_t::eSizeChanged) {
2093 if (layer->setSize(s.w, s.h)) {
2094 flags |= eTraversalNeeded;
2095 }
2096 }
2097 if (what & layer_state_t::eAlphaChanged) {
2098 if (layer->setAlpha(uint8_t(255.0f*s.alpha+0.5f)))
2099 flags |= eTraversalNeeded;
2100 }
2101 if (what & layer_state_t::eMatrixChanged) {
2102 if (layer->setMatrix(s.matrix))
2103 flags |= eTraversalNeeded;
2104 }
2105 if (what & layer_state_t::eTransparentRegionChanged) {
2106 if (layer->setTransparentRegionHint(s.transparentRegion))
2107 flags |= eTraversalNeeded;
2108 }
2109 if ((what & layer_state_t::eVisibilityChanged) ||
2110 (what & layer_state_t::eOpacityChanged)) {
2111 // TODO: should we just use an eFlagsChanged for this?
2112 if (layer->setFlags(s.flags, s.mask))
2113 flags |= eTraversalNeeded;
2114 }
2115 if (what & layer_state_t::eCropChanged) {
2116 if (layer->setCrop(s.crop))
2117 flags |= eTraversalNeeded;
2118 }
2119 if (what & layer_state_t::eLayerStackChanged) {
2120 // NOTE: index needs to be calculated before we update the state
2121 ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
2122 if (layer->setLayerStack(s.layerStack)) {
2123 mCurrentState.layersSortedByZ.removeAt(idx);
2124 mCurrentState.layersSortedByZ.add(layer);
2125 // we need traversal (state changed)
2126 // AND transaction (list changed)
2127 flags |= eTransactionNeeded|eTraversalNeeded;
2128 }
2129 }
2130 }
2131 return flags;
2132 }
2133
createLayer(const String8 & name,const sp<Client> & client,uint32_t w,uint32_t h,PixelFormat format,uint32_t flags,sp<IBinder> * handle,sp<IGraphicBufferProducer> * gbp)2134 status_t SurfaceFlinger::createLayer(
2135 const String8& name,
2136 const sp<Client>& client,
2137 uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
2138 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp)
2139 {
2140 //ALOGD("createLayer for (%d x %d), name=%s", w, h, name.string());
2141 if (int32_t(w|h) < 0) {
2142 ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
2143 int(w), int(h));
2144 return BAD_VALUE;
2145 }
2146
2147 status_t result = NO_ERROR;
2148
2149 sp<Layer> layer;
2150
2151 switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
2152 case ISurfaceComposerClient::eFXSurfaceNormal:
2153 result = createNormalLayer(client,
2154 name, w, h, flags, format,
2155 handle, gbp, &layer);
2156 break;
2157 case ISurfaceComposerClient::eFXSurfaceDim:
2158 result = createDimLayer(client,
2159 name, w, h, flags,
2160 handle, gbp, &layer);
2161 break;
2162 default:
2163 result = BAD_VALUE;
2164 break;
2165 }
2166
2167 if (result == NO_ERROR) {
2168 addClientLayer(client, *handle, *gbp, layer);
2169 setTransactionFlags(eTransactionNeeded);
2170 }
2171 return result;
2172 }
2173
createNormalLayer(const sp<Client> & client,const String8 & name,uint32_t w,uint32_t h,uint32_t flags,PixelFormat & format,sp<IBinder> * handle,sp<IGraphicBufferProducer> * gbp,sp<Layer> * outLayer)2174 status_t SurfaceFlinger::createNormalLayer(const sp<Client>& client,
2175 const String8& name, uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
2176 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
2177 {
2178 // initialize the surfaces
2179 switch (format) {
2180 case PIXEL_FORMAT_TRANSPARENT:
2181 case PIXEL_FORMAT_TRANSLUCENT:
2182 format = PIXEL_FORMAT_RGBA_8888;
2183 break;
2184 case PIXEL_FORMAT_OPAQUE:
2185 format = PIXEL_FORMAT_RGBX_8888;
2186 break;
2187 }
2188
2189 *outLayer = new Layer(this, client, name, w, h, flags);
2190 status_t err = (*outLayer)->setBuffers(w, h, format, flags);
2191 if (err == NO_ERROR) {
2192 *handle = (*outLayer)->getHandle();
2193 *gbp = (*outLayer)->getProducer();
2194 }
2195
2196 ALOGE_IF(err, "createNormalLayer() failed (%s)", strerror(-err));
2197 return err;
2198 }
2199
createDimLayer(const sp<Client> & client,const String8 & name,uint32_t w,uint32_t h,uint32_t flags,sp<IBinder> * handle,sp<IGraphicBufferProducer> * gbp,sp<Layer> * outLayer)2200 status_t SurfaceFlinger::createDimLayer(const sp<Client>& client,
2201 const String8& name, uint32_t w, uint32_t h, uint32_t flags,
2202 sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
2203 {
2204 *outLayer = new LayerDim(this, client, name, w, h, flags);
2205 *handle = (*outLayer)->getHandle();
2206 *gbp = (*outLayer)->getProducer();
2207 return NO_ERROR;
2208 }
2209
onLayerRemoved(const sp<Client> & client,const sp<IBinder> & handle)2210 status_t SurfaceFlinger::onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle)
2211 {
2212 // called by the window manager when it wants to remove a Layer
2213 status_t err = NO_ERROR;
2214 sp<Layer> l(client->getLayerUser(handle));
2215 if (l != NULL) {
2216 err = removeLayer(l);
2217 ALOGE_IF(err<0 && err != NAME_NOT_FOUND,
2218 "error removing layer=%p (%s)", l.get(), strerror(-err));
2219 }
2220 return err;
2221 }
2222
onLayerDestroyed(const wp<Layer> & layer)2223 status_t SurfaceFlinger::onLayerDestroyed(const wp<Layer>& layer)
2224 {
2225 // called by ~LayerCleaner() when all references to the IBinder (handle)
2226 // are gone
2227 status_t err = NO_ERROR;
2228 sp<Layer> l(layer.promote());
2229 if (l != NULL) {
2230 err = removeLayer(l);
2231 ALOGE_IF(err<0 && err != NAME_NOT_FOUND,
2232 "error removing layer=%p (%s)", l.get(), strerror(-err));
2233 }
2234 return err;
2235 }
2236
2237 // ---------------------------------------------------------------------------
2238
onInitializeDisplays()2239 void SurfaceFlinger::onInitializeDisplays() {
2240 // reset screen orientation and use primary layer stack
2241 Vector<ComposerState> state;
2242 Vector<DisplayState> displays;
2243 DisplayState d;
2244 d.what = DisplayState::eDisplayProjectionChanged |
2245 DisplayState::eLayerStackChanged;
2246 d.token = mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY];
2247 d.layerStack = 0;
2248 d.orientation = DisplayState::eOrientationDefault;
2249 d.frame.makeInvalid();
2250 d.viewport.makeInvalid();
2251 d.width = 0;
2252 d.height = 0;
2253 displays.add(d);
2254 setTransactionState(state, displays, 0);
2255 setPowerModeInternal(getDisplayDevice(d.token), HWC_POWER_MODE_NORMAL);
2256
2257 const nsecs_t period =
2258 getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
2259 mAnimFrameTracker.setDisplayRefreshPeriod(period);
2260 }
2261
initializeDisplays()2262 void SurfaceFlinger::initializeDisplays() {
2263 class MessageScreenInitialized : public MessageBase {
2264 SurfaceFlinger* flinger;
2265 public:
2266 MessageScreenInitialized(SurfaceFlinger* flinger) : flinger(flinger) { }
2267 virtual bool handler() {
2268 flinger->onInitializeDisplays();
2269 return true;
2270 }
2271 };
2272 sp<MessageBase> msg = new MessageScreenInitialized(this);
2273 postMessageAsync(msg); // we may be called from main thread, use async message
2274 }
2275
setPowerModeInternal(const sp<DisplayDevice> & hw,int mode)2276 void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& hw,
2277 int mode) {
2278 ALOGD("Set power mode=%d, type=%d flinger=%p", mode, hw->getDisplayType(),
2279 this);
2280 int32_t type = hw->getDisplayType();
2281 int currentMode = hw->getPowerMode();
2282
2283 if (mode == currentMode) {
2284 ALOGD("Screen type=%d is already mode=%d", hw->getDisplayType(), mode);
2285 return;
2286 }
2287
2288 hw->setPowerMode(mode);
2289 if (type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
2290 ALOGW("Trying to set power mode for virtual display");
2291 return;
2292 }
2293
2294 if (currentMode == HWC_POWER_MODE_OFF) {
2295 getHwComposer().setPowerMode(type, mode);
2296 if (type == DisplayDevice::DISPLAY_PRIMARY) {
2297 // FIXME: eventthread only knows about the main display right now
2298 mEventThread->onScreenAcquired();
2299 resyncToHardwareVsync(true);
2300 }
2301
2302 mVisibleRegionsDirty = true;
2303 repaintEverything();
2304 } else if (mode == HWC_POWER_MODE_OFF) {
2305 if (type == DisplayDevice::DISPLAY_PRIMARY) {
2306 disableHardwareVsync(true); // also cancels any in-progress resync
2307
2308 // FIXME: eventthread only knows about the main display right now
2309 mEventThread->onScreenReleased();
2310 }
2311
2312 getHwComposer().setPowerMode(type, mode);
2313 mVisibleRegionsDirty = true;
2314 // from this point on, SF will stop drawing on this display
2315 } else {
2316 getHwComposer().setPowerMode(type, mode);
2317 }
2318 }
2319
setPowerMode(const sp<IBinder> & display,int mode)2320 void SurfaceFlinger::setPowerMode(const sp<IBinder>& display, int mode) {
2321 class MessageSetPowerMode: public MessageBase {
2322 SurfaceFlinger& mFlinger;
2323 sp<IBinder> mDisplay;
2324 int mMode;
2325 public:
2326 MessageSetPowerMode(SurfaceFlinger& flinger,
2327 const sp<IBinder>& disp, int mode) : mFlinger(flinger),
2328 mDisplay(disp) { mMode = mode; }
2329 virtual bool handler() {
2330 sp<DisplayDevice> hw(mFlinger.getDisplayDevice(mDisplay));
2331 if (hw == NULL) {
2332 ALOGE("Attempt to set power mode = %d for null display %p",
2333 mMode, mDisplay.get());
2334 } else if (hw->getDisplayType() >= DisplayDevice::DISPLAY_VIRTUAL) {
2335 ALOGW("Attempt to set power mode = %d for virtual display",
2336 mMode);
2337 } else {
2338 mFlinger.setPowerModeInternal(hw, mMode);
2339 }
2340 return true;
2341 }
2342 };
2343 sp<MessageBase> msg = new MessageSetPowerMode(*this, display, mode);
2344 postMessageSync(msg);
2345 }
2346
2347 // ---------------------------------------------------------------------------
2348
dump(int fd,const Vector<String16> & args)2349 status_t SurfaceFlinger::dump(int fd, const Vector<String16>& args)
2350 {
2351 String8 result;
2352
2353 IPCThreadState* ipc = IPCThreadState::self();
2354 const int pid = ipc->getCallingPid();
2355 const int uid = ipc->getCallingUid();
2356 if ((uid != AID_SHELL) &&
2357 !PermissionCache::checkPermission(sDump, pid, uid)) {
2358 result.appendFormat("Permission Denial: "
2359 "can't dump SurfaceFlinger from pid=%d, uid=%d\n", pid, uid);
2360 } else {
2361 // Try to get the main lock, but don't insist if we can't
2362 // (this would indicate SF is stuck, but we want to be able to
2363 // print something in dumpsys).
2364 int retry = 3;
2365 while (mStateLock.tryLock()<0 && --retry>=0) {
2366 usleep(1000000);
2367 }
2368 const bool locked(retry >= 0);
2369 if (!locked) {
2370 result.append(
2371 "SurfaceFlinger appears to be unresponsive, "
2372 "dumping anyways (no locks held)\n");
2373 }
2374
2375 bool dumpAll = true;
2376 size_t index = 0;
2377 size_t numArgs = args.size();
2378 if (numArgs) {
2379 if ((index < numArgs) &&
2380 (args[index] == String16("--list"))) {
2381 index++;
2382 listLayersLocked(args, index, result);
2383 dumpAll = false;
2384 }
2385
2386 if ((index < numArgs) &&
2387 (args[index] == String16("--latency"))) {
2388 index++;
2389 dumpStatsLocked(args, index, result);
2390 dumpAll = false;
2391 }
2392
2393 if ((index < numArgs) &&
2394 (args[index] == String16("--latency-clear"))) {
2395 index++;
2396 clearStatsLocked(args, index, result);
2397 dumpAll = false;
2398 }
2399
2400 if ((index < numArgs) &&
2401 (args[index] == String16("--dispsync"))) {
2402 index++;
2403 mPrimaryDispSync.dump(result);
2404 dumpAll = false;
2405 }
2406 }
2407
2408 if (dumpAll) {
2409 dumpAllLocked(args, index, result);
2410 }
2411
2412 if (locked) {
2413 mStateLock.unlock();
2414 }
2415 }
2416 write(fd, result.string(), result.size());
2417 return NO_ERROR;
2418 }
2419
listLayersLocked(const Vector<String16> &,size_t &,String8 & result) const2420 void SurfaceFlinger::listLayersLocked(const Vector<String16>& /* args */,
2421 size_t& /* index */, String8& result) const
2422 {
2423 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
2424 const size_t count = currentLayers.size();
2425 for (size_t i=0 ; i<count ; i++) {
2426 const sp<Layer>& layer(currentLayers[i]);
2427 result.appendFormat("%s\n", layer->getName().string());
2428 }
2429 }
2430
dumpStatsLocked(const Vector<String16> & args,size_t & index,String8 & result) const2431 void SurfaceFlinger::dumpStatsLocked(const Vector<String16>& args, size_t& index,
2432 String8& result) const
2433 {
2434 String8 name;
2435 if (index < args.size()) {
2436 name = String8(args[index]);
2437 index++;
2438 }
2439
2440 const nsecs_t period =
2441 getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
2442 result.appendFormat("%" PRId64 "\n", period);
2443
2444 if (name.isEmpty()) {
2445 mAnimFrameTracker.dumpStats(result);
2446 } else {
2447 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
2448 const size_t count = currentLayers.size();
2449 for (size_t i=0 ; i<count ; i++) {
2450 const sp<Layer>& layer(currentLayers[i]);
2451 if (name == layer->getName()) {
2452 layer->dumpFrameStats(result);
2453 }
2454 }
2455 }
2456 }
2457
clearStatsLocked(const Vector<String16> & args,size_t & index,String8 &)2458 void SurfaceFlinger::clearStatsLocked(const Vector<String16>& args, size_t& index,
2459 String8& /* result */)
2460 {
2461 String8 name;
2462 if (index < args.size()) {
2463 name = String8(args[index]);
2464 index++;
2465 }
2466
2467 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
2468 const size_t count = currentLayers.size();
2469 for (size_t i=0 ; i<count ; i++) {
2470 const sp<Layer>& layer(currentLayers[i]);
2471 if (name.isEmpty() || (name == layer->getName())) {
2472 layer->clearFrameStats();
2473 }
2474 }
2475
2476 mAnimFrameTracker.clearStats();
2477 }
2478
2479 // This should only be called from the main thread. Otherwise it would need
2480 // the lock and should use mCurrentState rather than mDrawingState.
logFrameStats()2481 void SurfaceFlinger::logFrameStats() {
2482 const LayerVector& drawingLayers = mDrawingState.layersSortedByZ;
2483 const size_t count = drawingLayers.size();
2484 for (size_t i=0 ; i<count ; i++) {
2485 const sp<Layer>& layer(drawingLayers[i]);
2486 layer->logFrameStats();
2487 }
2488
2489 mAnimFrameTracker.logAndResetStats(String8("<win-anim>"));
2490 }
2491
appendSfConfigString(String8 & result)2492 /*static*/ void SurfaceFlinger::appendSfConfigString(String8& result)
2493 {
2494 static const char* config =
2495 " [sf"
2496 #ifdef HAS_CONTEXT_PRIORITY
2497 " HAS_CONTEXT_PRIORITY"
2498 #endif
2499 #ifdef NEVER_DEFAULT_TO_ASYNC_MODE
2500 " NEVER_DEFAULT_TO_ASYNC_MODE"
2501 #endif
2502 #ifdef TARGET_DISABLE_TRIPLE_BUFFERING
2503 " TARGET_DISABLE_TRIPLE_BUFFERING"
2504 #endif
2505 "]";
2506 result.append(config);
2507 }
2508
dumpAllLocked(const Vector<String16> & args,size_t & index,String8 & result) const2509 void SurfaceFlinger::dumpAllLocked(const Vector<String16>& args, size_t& index,
2510 String8& result) const
2511 {
2512 bool colorize = false;
2513 if (index < args.size()
2514 && (args[index] == String16("--color"))) {
2515 colorize = true;
2516 index++;
2517 }
2518
2519 Colorizer colorizer(colorize);
2520
2521 // figure out if we're stuck somewhere
2522 const nsecs_t now = systemTime();
2523 const nsecs_t inSwapBuffers(mDebugInSwapBuffers);
2524 const nsecs_t inTransaction(mDebugInTransaction);
2525 nsecs_t inSwapBuffersDuration = (inSwapBuffers) ? now-inSwapBuffers : 0;
2526 nsecs_t inTransactionDuration = (inTransaction) ? now-inTransaction : 0;
2527
2528 /*
2529 * Dump library configuration.
2530 */
2531
2532 colorizer.bold(result);
2533 result.append("Build configuration:");
2534 colorizer.reset(result);
2535 appendSfConfigString(result);
2536 appendUiConfigString(result);
2537 appendGuiConfigString(result);
2538 result.append("\n");
2539
2540 colorizer.bold(result);
2541 result.append("Sync configuration: ");
2542 colorizer.reset(result);
2543 result.append(SyncFeatures::getInstance().toString());
2544 result.append("\n");
2545
2546 colorizer.bold(result);
2547 result.append("DispSync configuration: ");
2548 colorizer.reset(result);
2549 result.appendFormat("app phase %" PRId64 " ns, sf phase %" PRId64 " ns, "
2550 "present offset %d ns (refresh %" PRId64 " ns)",
2551 vsyncPhaseOffsetNs, sfVsyncPhaseOffsetNs, PRESENT_TIME_OFFSET_FROM_VSYNC_NS,
2552 mHwc->getRefreshPeriod(HWC_DISPLAY_PRIMARY));
2553 result.append("\n");
2554
2555 /*
2556 * Dump the visible layer list
2557 */
2558 const LayerVector& currentLayers = mCurrentState.layersSortedByZ;
2559 const size_t count = currentLayers.size();
2560 colorizer.bold(result);
2561 result.appendFormat("Visible layers (count = %zu)\n", count);
2562 colorizer.reset(result);
2563 for (size_t i=0 ; i<count ; i++) {
2564 const sp<Layer>& layer(currentLayers[i]);
2565 layer->dump(result, colorizer);
2566 }
2567
2568 /*
2569 * Dump Display state
2570 */
2571
2572 colorizer.bold(result);
2573 result.appendFormat("Displays (%zu entries)\n", mDisplays.size());
2574 colorizer.reset(result);
2575 for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
2576 const sp<const DisplayDevice>& hw(mDisplays[dpy]);
2577 hw->dump(result);
2578 }
2579
2580 /*
2581 * Dump SurfaceFlinger global state
2582 */
2583
2584 colorizer.bold(result);
2585 result.append("SurfaceFlinger global state:\n");
2586 colorizer.reset(result);
2587
2588 HWComposer& hwc(getHwComposer());
2589 sp<const DisplayDevice> hw(getDefaultDisplayDevice());
2590
2591 colorizer.bold(result);
2592 result.appendFormat("EGL implementation : %s\n",
2593 eglQueryStringImplementationANDROID(mEGLDisplay, EGL_VERSION));
2594 colorizer.reset(result);
2595 result.appendFormat("%s\n",
2596 eglQueryStringImplementationANDROID(mEGLDisplay, EGL_EXTENSIONS));
2597
2598 mRenderEngine->dump(result);
2599
2600 hw->undefinedRegion.dump(result, "undefinedRegion");
2601 result.appendFormat(" orientation=%d, isDisplayOn=%d\n",
2602 hw->getOrientation(), hw->isDisplayOn());
2603 result.appendFormat(
2604 " last eglSwapBuffers() time: %f us\n"
2605 " last transaction time : %f us\n"
2606 " transaction-flags : %08x\n"
2607 " refresh-rate : %f fps\n"
2608 " x-dpi : %f\n"
2609 " y-dpi : %f\n"
2610 " gpu_to_cpu_unsupported : %d\n"
2611 ,
2612 mLastSwapBufferTime/1000.0,
2613 mLastTransactionTime/1000.0,
2614 mTransactionFlags,
2615 1e9 / hwc.getRefreshPeriod(HWC_DISPLAY_PRIMARY),
2616 hwc.getDpiX(HWC_DISPLAY_PRIMARY),
2617 hwc.getDpiY(HWC_DISPLAY_PRIMARY),
2618 !mGpuToCpuSupported);
2619
2620 result.appendFormat(" eglSwapBuffers time: %f us\n",
2621 inSwapBuffersDuration/1000.0);
2622
2623 result.appendFormat(" transaction time: %f us\n",
2624 inTransactionDuration/1000.0);
2625
2626 /*
2627 * VSYNC state
2628 */
2629 mEventThread->dump(result);
2630
2631 /*
2632 * Dump HWComposer state
2633 */
2634 colorizer.bold(result);
2635 result.append("h/w composer state:\n");
2636 colorizer.reset(result);
2637 result.appendFormat(" h/w composer %s and %s\n",
2638 hwc.initCheck()==NO_ERROR ? "present" : "not present",
2639 (mDebugDisableHWC || mDebugRegion || mDaltonize
2640 || mHasColorMatrix) ? "disabled" : "enabled");
2641 hwc.dump(result);
2642
2643 /*
2644 * Dump gralloc state
2645 */
2646 const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
2647 alloc.dump(result);
2648 }
2649
2650 const Vector< sp<Layer> >&
getLayerSortedByZForHwcDisplay(int id)2651 SurfaceFlinger::getLayerSortedByZForHwcDisplay(int id) {
2652 // Note: mStateLock is held here
2653 wp<IBinder> dpy;
2654 for (size_t i=0 ; i<mDisplays.size() ; i++) {
2655 if (mDisplays.valueAt(i)->getHwcDisplayId() == id) {
2656 dpy = mDisplays.keyAt(i);
2657 break;
2658 }
2659 }
2660 if (dpy == NULL) {
2661 ALOGE("getLayerSortedByZForHwcDisplay: invalid hwc display id %d", id);
2662 // Just use the primary display so we have something to return
2663 dpy = getBuiltInDisplay(DisplayDevice::DISPLAY_PRIMARY);
2664 }
2665 return getDisplayDevice(dpy)->getVisibleLayersSortedByZ();
2666 }
2667
startDdmConnection()2668 bool SurfaceFlinger::startDdmConnection()
2669 {
2670 void* libddmconnection_dso =
2671 dlopen("libsurfaceflinger_ddmconnection.so", RTLD_NOW);
2672 if (!libddmconnection_dso) {
2673 return false;
2674 }
2675 void (*DdmConnection_start)(const char* name);
2676 DdmConnection_start =
2677 (decltype(DdmConnection_start))dlsym(libddmconnection_dso, "DdmConnection_start");
2678 if (!DdmConnection_start) {
2679 dlclose(libddmconnection_dso);
2680 return false;
2681 }
2682 (*DdmConnection_start)(getServiceName());
2683 return true;
2684 }
2685
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)2686 status_t SurfaceFlinger::onTransact(
2687 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
2688 {
2689 switch (code) {
2690 case CREATE_CONNECTION:
2691 case CREATE_DISPLAY:
2692 case SET_TRANSACTION_STATE:
2693 case BOOT_FINISHED:
2694 case CLEAR_ANIMATION_FRAME_STATS:
2695 case GET_ANIMATION_FRAME_STATS:
2696 case SET_POWER_MODE:
2697 {
2698 // codes that require permission check
2699 IPCThreadState* ipc = IPCThreadState::self();
2700 const int pid = ipc->getCallingPid();
2701 const int uid = ipc->getCallingUid();
2702 if ((uid != AID_GRAPHICS) &&
2703 !PermissionCache::checkPermission(sAccessSurfaceFlinger, pid, uid)) {
2704 ALOGE("Permission Denial: "
2705 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
2706 return PERMISSION_DENIED;
2707 }
2708 break;
2709 }
2710 case CAPTURE_SCREEN:
2711 {
2712 // codes that require permission check
2713 IPCThreadState* ipc = IPCThreadState::self();
2714 const int pid = ipc->getCallingPid();
2715 const int uid = ipc->getCallingUid();
2716 if ((uid != AID_GRAPHICS) &&
2717 !PermissionCache::checkPermission(sReadFramebuffer, pid, uid)) {
2718 ALOGE("Permission Denial: "
2719 "can't read framebuffer pid=%d, uid=%d", pid, uid);
2720 return PERMISSION_DENIED;
2721 }
2722 break;
2723 }
2724 }
2725
2726 status_t err = BnSurfaceComposer::onTransact(code, data, reply, flags);
2727 if (err == UNKNOWN_TRANSACTION || err == PERMISSION_DENIED) {
2728 CHECK_INTERFACE(ISurfaceComposer, data, reply);
2729 if (CC_UNLIKELY(!PermissionCache::checkCallingPermission(sHardwareTest))) {
2730 IPCThreadState* ipc = IPCThreadState::self();
2731 const int pid = ipc->getCallingPid();
2732 const int uid = ipc->getCallingUid();
2733 ALOGE("Permission Denial: "
2734 "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
2735 return PERMISSION_DENIED;
2736 }
2737 int n;
2738 switch (code) {
2739 case 1000: // SHOW_CPU, NOT SUPPORTED ANYMORE
2740 case 1001: // SHOW_FPS, NOT SUPPORTED ANYMORE
2741 return NO_ERROR;
2742 case 1002: // SHOW_UPDATES
2743 n = data.readInt32();
2744 mDebugRegion = n ? n : (mDebugRegion ? 0 : 1);
2745 invalidateHwcGeometry();
2746 repaintEverything();
2747 return NO_ERROR;
2748 case 1004:{ // repaint everything
2749 repaintEverything();
2750 return NO_ERROR;
2751 }
2752 case 1005:{ // force transaction
2753 setTransactionFlags(
2754 eTransactionNeeded|
2755 eDisplayTransactionNeeded|
2756 eTraversalNeeded);
2757 return NO_ERROR;
2758 }
2759 case 1006:{ // send empty update
2760 signalRefresh();
2761 return NO_ERROR;
2762 }
2763 case 1008: // toggle use of hw composer
2764 n = data.readInt32();
2765 mDebugDisableHWC = n ? 1 : 0;
2766 invalidateHwcGeometry();
2767 repaintEverything();
2768 return NO_ERROR;
2769 case 1009: // toggle use of transform hint
2770 n = data.readInt32();
2771 mDebugDisableTransformHint = n ? 1 : 0;
2772 invalidateHwcGeometry();
2773 repaintEverything();
2774 return NO_ERROR;
2775 case 1010: // interrogate.
2776 reply->writeInt32(0);
2777 reply->writeInt32(0);
2778 reply->writeInt32(mDebugRegion);
2779 reply->writeInt32(0);
2780 reply->writeInt32(mDebugDisableHWC);
2781 return NO_ERROR;
2782 case 1013: {
2783 Mutex::Autolock _l(mStateLock);
2784 sp<const DisplayDevice> hw(getDefaultDisplayDevice());
2785 reply->writeInt32(hw->getPageFlipCount());
2786 return NO_ERROR;
2787 }
2788 case 1014: {
2789 // daltonize
2790 n = data.readInt32();
2791 switch (n % 10) {
2792 case 1: mDaltonizer.setType(Daltonizer::protanomaly); break;
2793 case 2: mDaltonizer.setType(Daltonizer::deuteranomaly); break;
2794 case 3: mDaltonizer.setType(Daltonizer::tritanomaly); break;
2795 }
2796 if (n >= 10) {
2797 mDaltonizer.setMode(Daltonizer::correction);
2798 } else {
2799 mDaltonizer.setMode(Daltonizer::simulation);
2800 }
2801 mDaltonize = n > 0;
2802 invalidateHwcGeometry();
2803 repaintEverything();
2804 return NO_ERROR;
2805 }
2806 case 1015: {
2807 // apply a color matrix
2808 n = data.readInt32();
2809 mHasColorMatrix = n ? 1 : 0;
2810 if (n) {
2811 // color matrix is sent as mat3 matrix followed by vec3
2812 // offset, then packed into a mat4 where the last row is
2813 // the offset and extra values are 0
2814 for (size_t i = 0 ; i < 4; i++) {
2815 for (size_t j = 0; j < 4; j++) {
2816 mColorMatrix[i][j] = data.readFloat();
2817 }
2818 }
2819 } else {
2820 mColorMatrix = mat4();
2821 }
2822 invalidateHwcGeometry();
2823 repaintEverything();
2824 return NO_ERROR;
2825 }
2826 // This is an experimental interface
2827 // Needs to be shifted to proper binder interface when we productize
2828 case 1016: {
2829 n = data.readInt32();
2830 mPrimaryDispSync.setRefreshSkipCount(n);
2831 return NO_ERROR;
2832 }
2833 }
2834 }
2835 return err;
2836 }
2837
repaintEverything()2838 void SurfaceFlinger::repaintEverything() {
2839 android_atomic_or(1, &mRepaintEverything);
2840 signalTransaction();
2841 }
2842
2843 // ---------------------------------------------------------------------------
2844 // Capture screen into an IGraphiBufferProducer
2845 // ---------------------------------------------------------------------------
2846
2847 /* The code below is here to handle b/8734824
2848 *
2849 * We create a IGraphicBufferProducer wrapper that forwards all calls
2850 * from the surfaceflinger thread to the calling binder thread, where they
2851 * are executed. This allows the calling thread in the calling process to be
2852 * reused and not depend on having "enough" binder threads to handle the
2853 * requests.
2854 */
2855 class GraphicProducerWrapper : public BBinder, public MessageHandler {
2856 /* Parts of GraphicProducerWrapper are run on two different threads,
2857 * communicating by sending messages via Looper but also by shared member
2858 * data. Coherence maintenance is subtle and in places implicit (ugh).
2859 *
2860 * Don't rely on Looper's sendMessage/handleMessage providing
2861 * release/acquire semantics for any data not actually in the Message.
2862 * Data going from surfaceflinger to binder threads needs to be
2863 * synchronized explicitly.
2864 *
2865 * Barrier open/wait do provide release/acquire semantics. This provides
2866 * implicit synchronization for data coming back from binder to
2867 * surfaceflinger threads.
2868 */
2869
2870 sp<IGraphicBufferProducer> impl;
2871 sp<Looper> looper;
2872 status_t result;
2873 bool exitPending;
2874 bool exitRequested;
2875 Barrier barrier;
2876 uint32_t code;
2877 Parcel const* data;
2878 Parcel* reply;
2879
2880 enum {
2881 MSG_API_CALL,
2882 MSG_EXIT
2883 };
2884
2885 /*
2886 * Called on surfaceflinger thread. This is called by our "fake"
2887 * BpGraphicBufferProducer. We package the data and reply Parcel and
2888 * forward them to the binder thread.
2889 */
transact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t)2890 virtual status_t transact(uint32_t code,
2891 const Parcel& data, Parcel* reply, uint32_t /* flags */) {
2892 this->code = code;
2893 this->data = &data;
2894 this->reply = reply;
2895 if (exitPending) {
2896 // if we've exited, we run the message synchronously right here.
2897 // note (JH): as far as I can tell from looking at the code, this
2898 // never actually happens. if it does, i'm not sure if it happens
2899 // on the surfaceflinger or binder thread.
2900 handleMessage(Message(MSG_API_CALL));
2901 } else {
2902 barrier.close();
2903 // Prevent stores to this->{code, data, reply} from being
2904 // reordered later than the construction of Message.
2905 atomic_thread_fence(memory_order_release);
2906 looper->sendMessage(this, Message(MSG_API_CALL));
2907 barrier.wait();
2908 }
2909 return result;
2910 }
2911
2912 /*
2913 * here we run on the binder thread. All we've got to do is
2914 * call the real BpGraphicBufferProducer.
2915 */
handleMessage(const Message & message)2916 virtual void handleMessage(const Message& message) {
2917 int what = message.what;
2918 // Prevent reads below from happening before the read from Message
2919 atomic_thread_fence(memory_order_acquire);
2920 if (what == MSG_API_CALL) {
2921 result = impl->asBinder()->transact(code, data[0], reply);
2922 barrier.open();
2923 } else if (what == MSG_EXIT) {
2924 exitRequested = true;
2925 }
2926 }
2927
2928 public:
GraphicProducerWrapper(const sp<IGraphicBufferProducer> & impl)2929 GraphicProducerWrapper(const sp<IGraphicBufferProducer>& impl)
2930 : impl(impl),
2931 looper(new Looper(true)),
2932 exitPending(false),
2933 exitRequested(false)
2934 {}
2935
2936 // Binder thread
waitForResponse()2937 status_t waitForResponse() {
2938 do {
2939 looper->pollOnce(-1);
2940 } while (!exitRequested);
2941 return result;
2942 }
2943
2944 // Client thread
exit(status_t result)2945 void exit(status_t result) {
2946 this->result = result;
2947 exitPending = true;
2948 // Ensure this->result is visible to the binder thread before it
2949 // handles the message.
2950 atomic_thread_fence(memory_order_release);
2951 looper->sendMessage(this, Message(MSG_EXIT));
2952 }
2953 };
2954
2955
captureScreen(const sp<IBinder> & display,const sp<IGraphicBufferProducer> & producer,Rect sourceCrop,uint32_t reqWidth,uint32_t reqHeight,uint32_t minLayerZ,uint32_t maxLayerZ,bool useIdentityTransform,ISurfaceComposer::Rotation rotation)2956 status_t SurfaceFlinger::captureScreen(const sp<IBinder>& display,
2957 const sp<IGraphicBufferProducer>& producer,
2958 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
2959 uint32_t minLayerZ, uint32_t maxLayerZ,
2960 bool useIdentityTransform, ISurfaceComposer::Rotation rotation) {
2961
2962 if (CC_UNLIKELY(display == 0))
2963 return BAD_VALUE;
2964
2965 if (CC_UNLIKELY(producer == 0))
2966 return BAD_VALUE;
2967
2968 // if we have secure windows on this display, never allow the screen capture
2969 // unless the producer interface is local (i.e.: we can take a screenshot for
2970 // ourselves).
2971 if (!producer->asBinder()->localBinder()) {
2972 Mutex::Autolock _l(mStateLock);
2973 sp<const DisplayDevice> hw(getDisplayDevice(display));
2974 if (hw->getSecureLayerVisible()) {
2975 ALOGW("FB is protected: PERMISSION_DENIED");
2976 return PERMISSION_DENIED;
2977 }
2978 }
2979
2980 // Convert to surfaceflinger's internal rotation type.
2981 Transform::orientation_flags rotationFlags;
2982 switch (rotation) {
2983 case ISurfaceComposer::eRotateNone:
2984 rotationFlags = Transform::ROT_0;
2985 break;
2986 case ISurfaceComposer::eRotate90:
2987 rotationFlags = Transform::ROT_90;
2988 break;
2989 case ISurfaceComposer::eRotate180:
2990 rotationFlags = Transform::ROT_180;
2991 break;
2992 case ISurfaceComposer::eRotate270:
2993 rotationFlags = Transform::ROT_270;
2994 break;
2995 default:
2996 rotationFlags = Transform::ROT_0;
2997 ALOGE("Invalid rotation passed to captureScreen(): %d\n", rotation);
2998 break;
2999 }
3000
3001 class MessageCaptureScreen : public MessageBase {
3002 SurfaceFlinger* flinger;
3003 sp<IBinder> display;
3004 sp<IGraphicBufferProducer> producer;
3005 Rect sourceCrop;
3006 uint32_t reqWidth, reqHeight;
3007 uint32_t minLayerZ,maxLayerZ;
3008 bool useIdentityTransform;
3009 Transform::orientation_flags rotation;
3010 status_t result;
3011 public:
3012 MessageCaptureScreen(SurfaceFlinger* flinger,
3013 const sp<IBinder>& display,
3014 const sp<IGraphicBufferProducer>& producer,
3015 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
3016 uint32_t minLayerZ, uint32_t maxLayerZ,
3017 bool useIdentityTransform, Transform::orientation_flags rotation)
3018 : flinger(flinger), display(display), producer(producer),
3019 sourceCrop(sourceCrop), reqWidth(reqWidth), reqHeight(reqHeight),
3020 minLayerZ(minLayerZ), maxLayerZ(maxLayerZ),
3021 useIdentityTransform(useIdentityTransform),
3022 rotation(rotation),
3023 result(PERMISSION_DENIED)
3024 {
3025 }
3026 status_t getResult() const {
3027 return result;
3028 }
3029 virtual bool handler() {
3030 Mutex::Autolock _l(flinger->mStateLock);
3031 sp<const DisplayDevice> hw(flinger->getDisplayDevice(display));
3032 result = flinger->captureScreenImplLocked(hw, producer,
3033 sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ,
3034 useIdentityTransform, rotation);
3035 static_cast<GraphicProducerWrapper*>(producer->asBinder().get())->exit(result);
3036 return true;
3037 }
3038 };
3039
3040 // make sure to process transactions before screenshots -- a transaction
3041 // might already be pending but scheduled for VSYNC; this guarantees we
3042 // will handle it before the screenshot. When VSYNC finally arrives
3043 // the scheduled transaction will be a no-op. If no transactions are
3044 // scheduled at this time, this will end-up being a no-op as well.
3045 mEventQueue.invalidateTransactionNow();
3046
3047 // this creates a "fake" BBinder which will serve as a "fake" remote
3048 // binder to receive the marshaled calls and forward them to the
3049 // real remote (a BpGraphicBufferProducer)
3050 sp<GraphicProducerWrapper> wrapper = new GraphicProducerWrapper(producer);
3051
3052 // the asInterface() call below creates our "fake" BpGraphicBufferProducer
3053 // which does the marshaling work forwards to our "fake remote" above.
3054 sp<MessageBase> msg = new MessageCaptureScreen(this,
3055 display, IGraphicBufferProducer::asInterface( wrapper ),
3056 sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ,
3057 useIdentityTransform, rotationFlags);
3058
3059 status_t res = postMessageAsync(msg);
3060 if (res == NO_ERROR) {
3061 res = wrapper->waitForResponse();
3062 }
3063 return res;
3064 }
3065
3066
renderScreenImplLocked(const sp<const DisplayDevice> & hw,Rect sourceCrop,uint32_t reqWidth,uint32_t reqHeight,uint32_t minLayerZ,uint32_t maxLayerZ,bool yswap,bool useIdentityTransform,Transform::orientation_flags rotation)3067 void SurfaceFlinger::renderScreenImplLocked(
3068 const sp<const DisplayDevice>& hw,
3069 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
3070 uint32_t minLayerZ, uint32_t maxLayerZ,
3071 bool yswap, bool useIdentityTransform, Transform::orientation_flags rotation)
3072 {
3073 ATRACE_CALL();
3074 RenderEngine& engine(getRenderEngine());
3075
3076 // get screen geometry
3077 const uint32_t hw_w = hw->getWidth();
3078 const uint32_t hw_h = hw->getHeight();
3079 const bool filtering = reqWidth != hw_w || reqWidth != hw_h;
3080
3081 // if a default or invalid sourceCrop is passed in, set reasonable values
3082 if (sourceCrop.width() == 0 || sourceCrop.height() == 0 ||
3083 !sourceCrop.isValid()) {
3084 sourceCrop.setLeftTop(Point(0, 0));
3085 sourceCrop.setRightBottom(Point(hw_w, hw_h));
3086 }
3087
3088 // ensure that sourceCrop is inside screen
3089 if (sourceCrop.left < 0) {
3090 ALOGE("Invalid crop rect: l = %d (< 0)", sourceCrop.left);
3091 }
3092 if (sourceCrop.right > hw_w) {
3093 ALOGE("Invalid crop rect: r = %d (> %d)", sourceCrop.right, hw_w);
3094 }
3095 if (sourceCrop.top < 0) {
3096 ALOGE("Invalid crop rect: t = %d (< 0)", sourceCrop.top);
3097 }
3098 if (sourceCrop.bottom > hw_h) {
3099 ALOGE("Invalid crop rect: b = %d (> %d)", sourceCrop.bottom, hw_h);
3100 }
3101
3102 // make sure to clear all GL error flags
3103 engine.checkErrors();
3104
3105 // set-up our viewport
3106 engine.setViewportAndProjection(
3107 reqWidth, reqHeight, sourceCrop, hw_h, yswap, rotation);
3108 engine.disableTexturing();
3109
3110 // redraw the screen entirely...
3111 engine.clearWithColor(0, 0, 0, 1);
3112
3113 const LayerVector& layers( mDrawingState.layersSortedByZ );
3114 const size_t count = layers.size();
3115 for (size_t i=0 ; i<count ; ++i) {
3116 const sp<Layer>& layer(layers[i]);
3117 const Layer::State& state(layer->getDrawingState());
3118 if (state.layerStack == hw->getLayerStack()) {
3119 if (state.z >= minLayerZ && state.z <= maxLayerZ) {
3120 if (layer->isVisible()) {
3121 if (filtering) layer->setFiltering(true);
3122 layer->draw(hw, useIdentityTransform);
3123 if (filtering) layer->setFiltering(false);
3124 }
3125 }
3126 }
3127 }
3128
3129 // compositionComplete is needed for older driver
3130 hw->compositionComplete();
3131 hw->setViewportAndProjection();
3132 }
3133
3134
captureScreenImplLocked(const sp<const DisplayDevice> & hw,const sp<IGraphicBufferProducer> & producer,Rect sourceCrop,uint32_t reqWidth,uint32_t reqHeight,uint32_t minLayerZ,uint32_t maxLayerZ,bool useIdentityTransform,Transform::orientation_flags rotation)3135 status_t SurfaceFlinger::captureScreenImplLocked(
3136 const sp<const DisplayDevice>& hw,
3137 const sp<IGraphicBufferProducer>& producer,
3138 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,
3139 uint32_t minLayerZ, uint32_t maxLayerZ,
3140 bool useIdentityTransform, Transform::orientation_flags rotation)
3141 {
3142 ATRACE_CALL();
3143
3144 // get screen geometry
3145 const uint32_t hw_w = hw->getWidth();
3146 const uint32_t hw_h = hw->getHeight();
3147
3148 if ((reqWidth > hw_w) || (reqHeight > hw_h)) {
3149 ALOGE("size mismatch (%d, %d) > (%d, %d)",
3150 reqWidth, reqHeight, hw_w, hw_h);
3151 return BAD_VALUE;
3152 }
3153
3154 reqWidth = (!reqWidth) ? hw_w : reqWidth;
3155 reqHeight = (!reqHeight) ? hw_h : reqHeight;
3156
3157 // create a surface (because we're a producer, and we need to
3158 // dequeue/queue a buffer)
3159 sp<Surface> sur = new Surface(producer, false);
3160 ANativeWindow* window = sur.get();
3161
3162 status_t result = NO_ERROR;
3163 if (native_window_api_connect(window, NATIVE_WINDOW_API_EGL) == NO_ERROR) {
3164 uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
3165 GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
3166
3167 int err = 0;
3168 err = native_window_set_buffers_dimensions(window, reqWidth, reqHeight);
3169 err |= native_window_set_scaling_mode(window, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
3170 err |= native_window_set_buffers_format(window, HAL_PIXEL_FORMAT_RGBA_8888);
3171 err |= native_window_set_usage(window, usage);
3172
3173 if (err == NO_ERROR) {
3174 ANativeWindowBuffer* buffer;
3175 /* TODO: Once we have the sync framework everywhere this can use
3176 * server-side waits on the fence that dequeueBuffer returns.
3177 */
3178 result = native_window_dequeue_buffer_and_wait(window, &buffer);
3179 if (result == NO_ERROR) {
3180 int syncFd = -1;
3181 // create an EGLImage from the buffer so we can later
3182 // turn it into a texture
3183 EGLImageKHR image = eglCreateImageKHR(mEGLDisplay, EGL_NO_CONTEXT,
3184 EGL_NATIVE_BUFFER_ANDROID, buffer, NULL);
3185 if (image != EGL_NO_IMAGE_KHR) {
3186 // this binds the given EGLImage as a framebuffer for the
3187 // duration of this scope.
3188 RenderEngine::BindImageAsFramebuffer imageBond(getRenderEngine(), image);
3189 if (imageBond.getStatus() == NO_ERROR) {
3190 // this will in fact render into our dequeued buffer
3191 // via an FBO, which means we didn't have to create
3192 // an EGLSurface and therefore we're not
3193 // dependent on the context's EGLConfig.
3194 renderScreenImplLocked(
3195 hw, sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ, true,
3196 useIdentityTransform, rotation);
3197
3198 // Attempt to create a sync khr object that can produce a sync point. If that
3199 // isn't available, create a non-dupable sync object in the fallback path and
3200 // wait on it directly.
3201 EGLSyncKHR sync;
3202 if (!DEBUG_SCREENSHOTS) {
3203 sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_NATIVE_FENCE_ANDROID, NULL);
3204 } else {
3205 sync = EGL_NO_SYNC_KHR;
3206 }
3207 if (sync != EGL_NO_SYNC_KHR) {
3208 // get the sync fd
3209 syncFd = eglDupNativeFenceFDANDROID(mEGLDisplay, sync);
3210 if (syncFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
3211 ALOGW("captureScreen: failed to dup sync khr object");
3212 syncFd = -1;
3213 }
3214 eglDestroySyncKHR(mEGLDisplay, sync);
3215 } else {
3216 // fallback path
3217 sync = eglCreateSyncKHR(mEGLDisplay, EGL_SYNC_FENCE_KHR, NULL);
3218 if (sync != EGL_NO_SYNC_KHR) {
3219 EGLint result = eglClientWaitSyncKHR(mEGLDisplay, sync,
3220 EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, 2000000000 /*2 sec*/);
3221 EGLint eglErr = eglGetError();
3222 if (result == EGL_TIMEOUT_EXPIRED_KHR) {
3223 ALOGW("captureScreen: fence wait timed out");
3224 } else {
3225 ALOGW_IF(eglErr != EGL_SUCCESS,
3226 "captureScreen: error waiting on EGL fence: %#x", eglErr);
3227 }
3228 eglDestroySyncKHR(mEGLDisplay, sync);
3229 } else {
3230 ALOGW("captureScreen: error creating EGL fence: %#x", eglGetError());
3231 }
3232 }
3233 if (DEBUG_SCREENSHOTS) {
3234 uint32_t* pixels = new uint32_t[reqWidth*reqHeight];
3235 getRenderEngine().readPixels(0, 0, reqWidth, reqHeight, pixels);
3236 checkScreenshot(reqWidth, reqHeight, reqWidth, pixels,
3237 hw, minLayerZ, maxLayerZ);
3238 delete [] pixels;
3239 }
3240
3241 } else {
3242 ALOGE("got GL_FRAMEBUFFER_COMPLETE_OES error while taking screenshot");
3243 result = INVALID_OPERATION;
3244 }
3245 // destroy our image
3246 eglDestroyImageKHR(mEGLDisplay, image);
3247 } else {
3248 result = BAD_VALUE;
3249 }
3250 // queueBuffer takes ownership of syncFd
3251 window->queueBuffer(window, buffer, syncFd);
3252 }
3253 } else {
3254 result = BAD_VALUE;
3255 }
3256 native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
3257 }
3258
3259 return result;
3260 }
3261
checkScreenshot(size_t w,size_t s,size_t h,void const * vaddr,const sp<const DisplayDevice> & hw,uint32_t minLayerZ,uint32_t maxLayerZ)3262 void SurfaceFlinger::checkScreenshot(size_t w, size_t s, size_t h, void const* vaddr,
3263 const sp<const DisplayDevice>& hw, uint32_t minLayerZ, uint32_t maxLayerZ) {
3264 if (DEBUG_SCREENSHOTS) {
3265 for (size_t y=0 ; y<h ; y++) {
3266 uint32_t const * p = (uint32_t const *)vaddr + y*s;
3267 for (size_t x=0 ; x<w ; x++) {
3268 if (p[x] != 0xFF000000) return;
3269 }
3270 }
3271 ALOGE("*** we just took a black screenshot ***\n"
3272 "requested minz=%d, maxz=%d, layerStack=%d",
3273 minLayerZ, maxLayerZ, hw->getLayerStack());
3274 const LayerVector& layers( mDrawingState.layersSortedByZ );
3275 const size_t count = layers.size();
3276 for (size_t i=0 ; i<count ; ++i) {
3277 const sp<Layer>& layer(layers[i]);
3278 const Layer::State& state(layer->getDrawingState());
3279 const bool visible = (state.layerStack == hw->getLayerStack())
3280 && (state.z >= minLayerZ && state.z <= maxLayerZ)
3281 && (layer->isVisible());
3282 ALOGE("%c index=%zu, name=%s, layerStack=%d, z=%d, visible=%d, flags=%x, alpha=%x",
3283 visible ? '+' : '-',
3284 i, layer->getName().string(), state.layerStack, state.z,
3285 layer->isVisible(), state.flags, state.alpha);
3286 }
3287 }
3288 }
3289
3290 // ---------------------------------------------------------------------------
3291
LayerVector()3292 SurfaceFlinger::LayerVector::LayerVector() {
3293 }
3294
LayerVector(const LayerVector & rhs)3295 SurfaceFlinger::LayerVector::LayerVector(const LayerVector& rhs)
3296 : SortedVector<sp<Layer> >(rhs) {
3297 }
3298
do_compare(const void * lhs,const void * rhs) const3299 int SurfaceFlinger::LayerVector::do_compare(const void* lhs,
3300 const void* rhs) const
3301 {
3302 // sort layers per layer-stack, then by z-order and finally by sequence
3303 const sp<Layer>& l(*reinterpret_cast<const sp<Layer>*>(lhs));
3304 const sp<Layer>& r(*reinterpret_cast<const sp<Layer>*>(rhs));
3305
3306 uint32_t ls = l->getCurrentState().layerStack;
3307 uint32_t rs = r->getCurrentState().layerStack;
3308 if (ls != rs)
3309 return ls - rs;
3310
3311 uint32_t lz = l->getCurrentState().z;
3312 uint32_t rz = r->getCurrentState().z;
3313 if (lz != rz)
3314 return lz - rz;
3315
3316 return l->sequence - r->sequence;
3317 }
3318
3319 // ---------------------------------------------------------------------------
3320
DisplayDeviceState()3321 SurfaceFlinger::DisplayDeviceState::DisplayDeviceState()
3322 : type(DisplayDevice::DISPLAY_ID_INVALID), width(0), height(0) {
3323 }
3324
DisplayDeviceState(DisplayDevice::DisplayType type)3325 SurfaceFlinger::DisplayDeviceState::DisplayDeviceState(DisplayDevice::DisplayType type)
3326 : type(type), layerStack(DisplayDevice::NO_LAYER_STACK), orientation(0), width(0), height(0) {
3327 viewport.makeInvalid();
3328 frame.makeInvalid();
3329 }
3330
3331 // ---------------------------------------------------------------------------
3332
3333 }; // namespace android
3334
3335
3336 #if defined(__gl_h_)
3337 #error "don't include gl/gl.h in this file"
3338 #endif
3339
3340 #if defined(__gl2_h_)
3341 #error "don't include gl2/gl2.h in this file"
3342 #endif
3343