1 /*
2 * Copyright (C) 2012 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 //#define LOG_NDEBUG 0
19
20 #include "SurfaceFlingerConsumer.h"
21
22 #include <private/gui/SyncFeatures.h>
23
24 #include <gui/BufferItem.h>
25
26 #include <utils/Errors.h>
27 #include <utils/NativeHandle.h>
28 #include <utils/Trace.h>
29
30 namespace android {
31
32 // ---------------------------------------------------------------------------
33
updateTexImage(BufferRejecter * rejecter,const DispSync & dispSync,uint64_t maxFrameNumber)34 status_t SurfaceFlingerConsumer::updateTexImage(BufferRejecter* rejecter,
35 const DispSync& dispSync, uint64_t maxFrameNumber)
36 {
37 ATRACE_CALL();
38 ALOGV("updateTexImage");
39 Mutex::Autolock lock(mMutex);
40
41 if (mAbandoned) {
42 ALOGE("updateTexImage: GLConsumer is abandoned!");
43 return NO_INIT;
44 }
45
46 // Make sure the EGL state is the same as in previous calls.
47 status_t err = checkAndUpdateEglStateLocked();
48 if (err != NO_ERROR) {
49 return err;
50 }
51
52 BufferItem item;
53
54 // Acquire the next buffer.
55 // In asynchronous mode the list is guaranteed to be one buffer
56 // deep, while in synchronous mode we use the oldest buffer.
57 err = acquireBufferLocked(&item, computeExpectedPresent(dispSync),
58 maxFrameNumber);
59 if (err != NO_ERROR) {
60 if (err == BufferQueue::NO_BUFFER_AVAILABLE) {
61 err = NO_ERROR;
62 } else if (err == BufferQueue::PRESENT_LATER) {
63 // return the error, without logging
64 } else {
65 ALOGE("updateTexImage: acquire failed: %s (%d)",
66 strerror(-err), err);
67 }
68 return err;
69 }
70
71
72 // We call the rejecter here, in case the caller has a reason to
73 // not accept this buffer. This is used by SurfaceFlinger to
74 // reject buffers which have the wrong size
75 int buf = item.mBuf;
76 if (rejecter && rejecter->reject(mSlots[buf].mGraphicBuffer, item)) {
77 releaseBufferLocked(buf, mSlots[buf].mGraphicBuffer, EGL_NO_SYNC_KHR);
78 return BUFFER_REJECTED;
79 }
80
81 // Release the previous buffer.
82 err = updateAndReleaseLocked(item);
83 if (err != NO_ERROR) {
84 return err;
85 }
86
87 if (!SyncFeatures::getInstance().useNativeFenceSync()) {
88 // Bind the new buffer to the GL texture.
89 //
90 // Older devices require the "implicit" synchronization provided
91 // by glEGLImageTargetTexture2DOES, which this method calls. Newer
92 // devices will either call this in Layer::onDraw, or (if it's not
93 // a GL-composited layer) not at all.
94 err = bindTextureImageLocked();
95 }
96
97 return err;
98 }
99
bindTextureImage()100 status_t SurfaceFlingerConsumer::bindTextureImage()
101 {
102 Mutex::Autolock lock(mMutex);
103
104 return bindTextureImageLocked();
105 }
106
acquireBufferLocked(BufferItem * item,nsecs_t presentWhen,uint64_t maxFrameNumber)107 status_t SurfaceFlingerConsumer::acquireBufferLocked(BufferItem* item,
108 nsecs_t presentWhen, uint64_t maxFrameNumber) {
109 status_t result = GLConsumer::acquireBufferLocked(item, presentWhen,
110 maxFrameNumber);
111 if (result == NO_ERROR) {
112 mTransformToDisplayInverse = item->mTransformToDisplayInverse;
113 mSurfaceDamage = item->mSurfaceDamage;
114 }
115 return result;
116 }
117
getTransformToDisplayInverse() const118 bool SurfaceFlingerConsumer::getTransformToDisplayInverse() const {
119 return mTransformToDisplayInverse;
120 }
121
getSurfaceDamage() const122 const Region& SurfaceFlingerConsumer::getSurfaceDamage() const {
123 return mSurfaceDamage;
124 }
125
getSidebandStream() const126 sp<NativeHandle> SurfaceFlingerConsumer::getSidebandStream() const {
127 return mConsumer->getSidebandStream();
128 }
129
130 // We need to determine the time when a buffer acquired now will be
131 // displayed. This can be calculated:
132 // time when previous buffer's actual-present fence was signaled
133 // + current display refresh rate * HWC latency
134 // + a little extra padding
135 //
136 // Buffer producers are expected to set their desired presentation time
137 // based on choreographer time stamps, which (coming from vsync events)
138 // will be slightly later then the actual-present timing. If we get a
139 // desired-present time that is unintentionally a hair after the next
140 // vsync, we'll hold the frame when we really want to display it. We
141 // need to take the offset between actual-present and reported-vsync
142 // into account.
143 //
144 // If the system is configured without a DispSync phase offset for the app,
145 // we also want to throw in a bit of padding to avoid edge cases where we
146 // just barely miss. We want to do it here, not in every app. A major
147 // source of trouble is the app's use of the display's ideal refresh time
148 // (via Display.getRefreshRate()), which could be off of the actual refresh
149 // by a few percent, with the error multiplied by the number of frames
150 // between now and when the buffer should be displayed.
151 //
152 // If the refresh reported to the app has a phase offset, we shouldn't need
153 // to tweak anything here.
computeExpectedPresent(const DispSync & dispSync)154 nsecs_t SurfaceFlingerConsumer::computeExpectedPresent(const DispSync& dispSync)
155 {
156 // The HWC doesn't currently have a way to report additional latency.
157 // Assume that whatever we submit now will appear right after the flip.
158 // For a smart panel this might be 1. This is expressed in frames,
159 // rather than time, because we expect to have a constant frame delay
160 // regardless of the refresh rate.
161 const uint32_t hwcLatency = 0;
162
163 // Ask DispSync when the next refresh will be (CLOCK_MONOTONIC).
164 const nsecs_t nextRefresh = dispSync.computeNextRefresh(hwcLatency);
165
166 // The DispSync time is already adjusted for the difference between
167 // vsync and reported-vsync (PRESENT_TIME_OFFSET_FROM_VSYNC_NS), so
168 // we don't need to factor that in here. Pad a little to avoid
169 // weird effects if apps might be requesting times right on the edge.
170 nsecs_t extraPadding = 0;
171 if (VSYNC_EVENT_PHASE_OFFSET_NS == 0) {
172 extraPadding = 1000000; // 1ms (6% of 60Hz)
173 }
174
175 return nextRefresh + extraPadding;
176 }
177
setContentsChangedListener(const wp<ContentsChangedListener> & listener)178 void SurfaceFlingerConsumer::setContentsChangedListener(
179 const wp<ContentsChangedListener>& listener) {
180 setFrameAvailableListener(listener);
181 Mutex::Autolock lock(mMutex);
182 mContentsChangedListener = listener;
183 }
184
onSidebandStreamChanged()185 void SurfaceFlingerConsumer::onSidebandStreamChanged() {
186 sp<ContentsChangedListener> listener;
187 { // scope for the lock
188 Mutex::Autolock lock(mMutex);
189 ALOG_ASSERT(mFrameAvailableListener.unsafe_get() == mContentsChangedListener.unsafe_get());
190 listener = mContentsChangedListener.promote();
191 }
192
193 if (listener != NULL) {
194 listener->onSidebandStreamChanged();
195 }
196 }
197
198 // ---------------------------------------------------------------------------
199 }; // namespace android
200
201