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 <utils/Trace.h>
25 #include <utils/Errors.h>
26
27 namespace android {
28
29 // ---------------------------------------------------------------------------
30
updateTexImage(BufferRejecter * rejecter)31 status_t SurfaceFlingerConsumer::updateTexImage(BufferRejecter* rejecter)
32 {
33 ATRACE_CALL();
34 ALOGV("updateTexImage");
35 Mutex::Autolock lock(mMutex);
36
37 if (mAbandoned) {
38 ALOGE("updateTexImage: GLConsumer is abandoned!");
39 return NO_INIT;
40 }
41
42 // Make sure the EGL state is the same as in previous calls.
43 status_t err = checkAndUpdateEglStateLocked();
44 if (err != NO_ERROR) {
45 return err;
46 }
47
48 BufferQueue::BufferItem item;
49
50 // Acquire the next buffer.
51 // In asynchronous mode the list is guaranteed to be one buffer
52 // deep, while in synchronous mode we use the oldest buffer.
53 err = acquireBufferLocked(&item, computeExpectedPresent());
54 if (err != NO_ERROR) {
55 if (err == BufferQueue::NO_BUFFER_AVAILABLE) {
56 err = NO_ERROR;
57 } else if (err == BufferQueue::PRESENT_LATER) {
58 // return the error, without logging
59 } else {
60 ALOGE("updateTexImage: acquire failed: %s (%d)",
61 strerror(-err), err);
62 }
63 return err;
64 }
65
66
67 // We call the rejecter here, in case the caller has a reason to
68 // not accept this buffer. This is used by SurfaceFlinger to
69 // reject buffers which have the wrong size
70 int buf = item.mBuf;
71 if (rejecter && rejecter->reject(mSlots[buf].mGraphicBuffer, item)) {
72 releaseBufferLocked(buf, mSlots[buf].mGraphicBuffer, EGL_NO_SYNC_KHR);
73 return NO_ERROR;
74 }
75
76 // Release the previous buffer.
77 err = updateAndReleaseLocked(item);
78 if (err != NO_ERROR) {
79 return err;
80 }
81
82 if (!SyncFeatures::getInstance().useNativeFenceSync()) {
83 // Bind the new buffer to the GL texture.
84 //
85 // Older devices require the "implicit" synchronization provided
86 // by glEGLImageTargetTexture2DOES, which this method calls. Newer
87 // devices will either call this in Layer::onDraw, or (if it's not
88 // a GL-composited layer) not at all.
89 err = bindTextureImageLocked();
90 }
91
92 return err;
93 }
94
bindTextureImage()95 status_t SurfaceFlingerConsumer::bindTextureImage()
96 {
97 Mutex::Autolock lock(mMutex);
98
99 return bindTextureImageLocked();
100 }
101
acquireBufferLocked(BufferQueue::BufferItem * item,nsecs_t presentWhen)102 status_t SurfaceFlingerConsumer::acquireBufferLocked(
103 BufferQueue::BufferItem *item, nsecs_t presentWhen) {
104 status_t result = GLConsumer::acquireBufferLocked(item, presentWhen);
105 if (result == NO_ERROR) {
106 mTransformToDisplayInverse = item->mTransformToDisplayInverse;
107 }
108 return result;
109 }
110
getTransformToDisplayInverse() const111 bool SurfaceFlingerConsumer::getTransformToDisplayInverse() const {
112 return mTransformToDisplayInverse;
113 }
114
115 // We need to determine the time when a buffer acquired now will be
116 // displayed. This can be calculated:
117 // time when previous buffer's actual-present fence was signaled
118 // + current display refresh rate * HWC latency
119 // + a little extra padding
120 //
121 // Buffer producers are expected to set their desired presentation time
122 // based on choreographer time stamps, which (coming from vsync events)
123 // will be slightly later then the actual-present timing. If we get a
124 // desired-present time that is unintentionally a hair after the next
125 // vsync, we'll hold the frame when we really want to display it. We
126 // want to use an expected-presentation time that is slightly late to
127 // avoid this sort of edge case.
computeExpectedPresent()128 nsecs_t SurfaceFlingerConsumer::computeExpectedPresent()
129 {
130 // Don't yet have an easy way to get actual buffer flip time for
131 // the specific display, so use the current time. This is typically
132 // 1.3ms past the vsync event time.
133 const nsecs_t prevVsync = systemTime(CLOCK_MONOTONIC);
134
135 // Given a SurfaceFlinger reference, and information about what display
136 // we're destined for, we could query the HWC for the refresh rate. This
137 // could change over time, e.g. we could switch to 24fps for a movie.
138 // For now, assume 60fps.
139 //const nsecs_t vsyncPeriod =
140 // getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
141 const nsecs_t vsyncPeriod = 16700000;
142
143 // The HWC doesn't currently have a way to report additional latency.
144 // Assume that whatever we submit now will appear on the next flip,
145 // i.e. 1 frame of latency w.r.t. the previous flip.
146 const uint32_t hwcLatency = 1;
147
148 // A little extra padding to compensate for slack between actual vsync
149 // time and vsync event receipt. Currently not needed since we're
150 // using "now" instead of a vsync time.
151 const nsecs_t extraPadding = 0;
152
153 // Total it up.
154 return prevVsync + hwcLatency * vsyncPeriod + extraPadding;
155 }
156
157 // ---------------------------------------------------------------------------
158 }; // namespace android
159
160