1 /*
2 **
3 ** Copyright 2012 The Android Open Source Project
4 **
5 ** Licensed under the Apache License Version 2.0(the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
8 **
9 ** http://www.apache.org/licenses/LICENSE-2.0
10 **
11 ** Unless required by applicable law or agreed to in writing software
12 ** distributed under the License is distributed on an "AS IS" BASIS
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
16 */
17
18 // #define LOG_NDEBUG 0
19 #undef LOG_TAG
20 #define LOG_TAG "FramebufferSurface"
21
22 #include <stdlib.h>
23 #include <stdio.h>
24 #include <string.h>
25 #include <errno.h>
26
27 #include <cutils/log.h>
28
29 #include <utils/String8.h>
30
31 #include <ui/Rect.h>
32
33 #include <EGL/egl.h>
34
35 #include <hardware/hardware.h>
36 #include <gui/BufferItem.h>
37 #include <gui/GraphicBufferAlloc.h>
38 #include <gui/Surface.h>
39 #include <ui/GraphicBuffer.h>
40
41 #include "FramebufferSurface.h"
42 #include "HWComposer.h"
43
44 #ifndef NUM_FRAMEBUFFER_SURFACE_BUFFERS
45 #define NUM_FRAMEBUFFER_SURFACE_BUFFERS (2)
46 #endif
47
48 // ----------------------------------------------------------------------------
49 namespace android {
50 // ----------------------------------------------------------------------------
51
52 /*
53 * This implements the (main) framebuffer management. This class is used
54 * mostly by SurfaceFlinger, but also by command line GL application.
55 *
56 */
57
FramebufferSurface(HWComposer & hwc,int disp,const sp<IGraphicBufferConsumer> & consumer)58 FramebufferSurface::FramebufferSurface(HWComposer& hwc, int disp,
59 const sp<IGraphicBufferConsumer>& consumer) :
60 ConsumerBase(consumer),
61 mDisplayType(disp),
62 mCurrentBufferSlot(-1),
63 mCurrentBuffer(),
64 mCurrentFence(Fence::NO_FENCE),
65 #ifdef USE_HWC2
66 mHwc(hwc),
67 mHasPendingRelease(false),
68 mPreviousBufferSlot(BufferQueue::INVALID_BUFFER_SLOT),
69 mPreviousBuffer()
70 #else
71 mHwc(hwc)
72 #endif
73 {
74 #ifdef USE_HWC2
75 ALOGV("Creating for display %d", disp);
76 #endif
77
78 mName = "FramebufferSurface";
79 mConsumer->setConsumerName(mName);
80 mConsumer->setConsumerUsageBits(GRALLOC_USAGE_HW_FB |
81 GRALLOC_USAGE_HW_RENDER |
82 GRALLOC_USAGE_HW_COMPOSER);
83 #ifdef USE_HWC2
84 const auto& activeConfig = mHwc.getActiveConfig(disp);
85 mConsumer->setDefaultBufferSize(activeConfig->getWidth(),
86 activeConfig->getHeight());
87 #else
88 mConsumer->setDefaultBufferFormat(mHwc.getFormat(disp));
89 mConsumer->setDefaultBufferSize(mHwc.getWidth(disp), mHwc.getHeight(disp));
90 #endif
91 mConsumer->setMaxAcquiredBufferCount(NUM_FRAMEBUFFER_SURFACE_BUFFERS - 1);
92 }
93
beginFrame(bool)94 status_t FramebufferSurface::beginFrame(bool /*mustRecompose*/) {
95 return NO_ERROR;
96 }
97
prepareFrame(CompositionType)98 status_t FramebufferSurface::prepareFrame(CompositionType /*compositionType*/) {
99 return NO_ERROR;
100 }
101
advanceFrame()102 status_t FramebufferSurface::advanceFrame() {
103 #ifdef USE_HWC2
104 sp<GraphicBuffer> buf;
105 sp<Fence> acquireFence(Fence::NO_FENCE);
106 android_dataspace_t dataspace = HAL_DATASPACE_UNKNOWN;
107 status_t result = nextBuffer(buf, acquireFence, dataspace);
108 if (result != NO_ERROR) {
109 ALOGE("error latching next FramebufferSurface buffer: %s (%d)",
110 strerror(-result), result);
111 return result;
112 }
113 result = mHwc.setClientTarget(mDisplayType, acquireFence, buf, dataspace);
114 if (result != NO_ERROR) {
115 ALOGE("error posting framebuffer: %d", result);
116 }
117 return result;
118 #else
119 // Once we remove FB HAL support, we can call nextBuffer() from here
120 // instead of using onFrameAvailable(). No real benefit, except it'll be
121 // more like VirtualDisplaySurface.
122 return NO_ERROR;
123 #endif
124 }
125
126 #ifdef USE_HWC2
nextBuffer(sp<GraphicBuffer> & outBuffer,sp<Fence> & outFence,android_dataspace_t & outDataspace)127 status_t FramebufferSurface::nextBuffer(sp<GraphicBuffer>& outBuffer,
128 sp<Fence>& outFence, android_dataspace_t& outDataspace) {
129 #else
130 status_t FramebufferSurface::nextBuffer(sp<GraphicBuffer>& outBuffer, sp<Fence>& outFence) {
131 #endif
132 Mutex::Autolock lock(mMutex);
133
134 BufferItem item;
135 status_t err = acquireBufferLocked(&item, 0);
136 if (err == BufferQueue::NO_BUFFER_AVAILABLE) {
137 outBuffer = mCurrentBuffer;
138 return NO_ERROR;
139 } else if (err != NO_ERROR) {
140 ALOGE("error acquiring buffer: %s (%d)", strerror(-err), err);
141 return err;
142 }
143
144 // If the BufferQueue has freed and reallocated a buffer in mCurrentSlot
145 // then we may have acquired the slot we already own. If we had released
146 // our current buffer before we call acquireBuffer then that release call
147 // would have returned STALE_BUFFER_SLOT, and we would have called
148 // freeBufferLocked on that slot. Because the buffer slot has already
149 // been overwritten with the new buffer all we have to do is skip the
150 // releaseBuffer call and we should be in the same state we'd be in if we
151 // had released the old buffer first.
152 if (mCurrentBufferSlot != BufferQueue::INVALID_BUFFER_SLOT &&
153 item.mSlot != mCurrentBufferSlot) {
154 #ifdef USE_HWC2
155 mHasPendingRelease = true;
156 mPreviousBufferSlot = mCurrentBufferSlot;
157 mPreviousBuffer = mCurrentBuffer;
158 #else
159 // Release the previous buffer.
160 err = releaseBufferLocked(mCurrentBufferSlot, mCurrentBuffer,
161 EGL_NO_DISPLAY, EGL_NO_SYNC_KHR);
162 if (err < NO_ERROR) {
163 ALOGE("error releasing buffer: %s (%d)", strerror(-err), err);
164 return err;
165 }
166 #endif
167 }
168 mCurrentBufferSlot = item.mSlot;
169 mCurrentBuffer = mSlots[mCurrentBufferSlot].mGraphicBuffer;
170 mCurrentFence = item.mFence;
171
172 outFence = item.mFence;
173 outBuffer = mCurrentBuffer;
174 #ifdef USE_HWC2
175 outDataspace = item.mDataSpace;
176 #endif
177 return NO_ERROR;
178 }
179
180 #ifndef USE_HWC2
181 // Overrides ConsumerBase::onFrameAvailable(), does not call base class impl.
182 void FramebufferSurface::onFrameAvailable(const BufferItem& /* item */) {
183 sp<GraphicBuffer> buf;
184 sp<Fence> acquireFence;
185 status_t err = nextBuffer(buf, acquireFence);
186 if (err != NO_ERROR) {
187 ALOGE("error latching nnext FramebufferSurface buffer: %s (%d)",
188 strerror(-err), err);
189 return;
190 }
191 err = mHwc.fbPost(mDisplayType, acquireFence, buf);
192 if (err != NO_ERROR) {
193 ALOGE("error posting framebuffer: %d", err);
194 }
195 }
196 #endif
197
198 void FramebufferSurface::freeBufferLocked(int slotIndex) {
199 ConsumerBase::freeBufferLocked(slotIndex);
200 if (slotIndex == mCurrentBufferSlot) {
201 mCurrentBufferSlot = BufferQueue::INVALID_BUFFER_SLOT;
202 }
203 }
204
205 void FramebufferSurface::onFrameCommitted() {
206 #ifdef USE_HWC2
207 if (mHasPendingRelease) {
208 sp<Fence> fence = mHwc.getRetireFence(mDisplayType);
209 if (fence->isValid()) {
210 status_t result = addReleaseFence(mPreviousBufferSlot,
211 mPreviousBuffer, fence);
212 ALOGE_IF(result != NO_ERROR, "onFrameCommitted: failed to add the"
213 " fence: %s (%d)", strerror(-result), result);
214 }
215 status_t result = releaseBufferLocked(mPreviousBufferSlot,
216 mPreviousBuffer, EGL_NO_DISPLAY, EGL_NO_SYNC_KHR);
217 ALOGE_IF(result != NO_ERROR, "onFrameCommitted: error releasing buffer:"
218 " %s (%d)", strerror(-result), result);
219
220 mPreviousBuffer.clear();
221 mHasPendingRelease = false;
222 }
223 #else
224 sp<Fence> fence = mHwc.getAndResetReleaseFence(mDisplayType);
225 if (fence->isValid() &&
226 mCurrentBufferSlot != BufferQueue::INVALID_BUFFER_SLOT) {
227 status_t err = addReleaseFence(mCurrentBufferSlot,
228 mCurrentBuffer, fence);
229 ALOGE_IF(err, "setReleaseFenceFd: failed to add the fence: %s (%d)",
230 strerror(-err), err);
231 }
232 #endif
233 }
234
235 #ifndef USE_HWC2
236 status_t FramebufferSurface::compositionComplete()
237 {
238 return mHwc.fbCompositionComplete();
239 }
240 #endif
241
242 void FramebufferSurface::dumpAsString(String8& result) const {
243 ConsumerBase::dump(result);
244 }
245
246 void FramebufferSurface::dumpLocked(String8& result, const char* prefix) const
247 {
248 #ifndef USE_HWC2
249 mHwc.fbDump(result);
250 #endif
251 ConsumerBase::dumpLocked(result, prefix);
252 }
253
254 const sp<Fence>& FramebufferSurface::getClientTargetAcquireFence() const {
255 return mCurrentFence;
256 }
257
258 // ----------------------------------------------------------------------------
259 }; // namespace android
260 // ----------------------------------------------------------------------------
261