3 ** Copyright 2012 The Android Open Source Project
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
9 ** http://www.apache.org/licenses/LICENSE-2.0
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.
23 #include <cutils/log.h>
25 #include <utils/String8.h>
31 #include <hardware/hardware.h>
32 #include <gui/BufferItem.h>
33 #include <gui/GraphicBufferAlloc.h>
34 #include <gui/Surface.h>
35 #include <ui/GraphicBuffer.h>
37 #include "FramebufferSurface.h"
38 #include "HWComposer.h"
40 #ifndef NUM_FRAMEBUFFER_SURFACE_BUFFERS
41 #define NUM_FRAMEBUFFER_SURFACE_BUFFERS (2)
44 // ----------------------------------------------------------------------------
46 // ----------------------------------------------------------------------------
49 * This implements the (main) framebuffer management. This class is used
50 * mostly by SurfaceFlinger, but also by command line GL application.
54 FramebufferSurface::FramebufferSurface(HWComposer& hwc, int disp,
55 const sp<IGraphicBufferConsumer>& consumer) :
56 ConsumerBase(consumer),
58 mCurrentBufferSlot(-1),
62 mName = "FramebufferSurface";
63 mConsumer->setConsumerName(mName);
64 mConsumer->setConsumerUsageBits(GRALLOC_USAGE_HW_FB |
65 GRALLOC_USAGE_HW_RENDER |
66 GRALLOC_USAGE_HW_COMPOSER);
67 mConsumer->setDefaultBufferFormat(mHwc.getFormat(disp));
68 mConsumer->setDefaultBufferSize(mHwc.getWidth(disp), mHwc.getHeight(disp));
69 mConsumer->setDefaultMaxBufferCount(NUM_FRAMEBUFFER_SURFACE_BUFFERS);
70 mConsumer->setMaxAcquiredBufferCount(NUM_FRAMEBUFFER_SURFACE_BUFFERS - 1);
73 status_t FramebufferSurface::beginFrame(bool /*mustRecompose*/) {
77 status_t FramebufferSurface::prepareFrame(CompositionType /*compositionType*/) {
81 status_t FramebufferSurface::advanceFrame() {
82 // Once we remove FB HAL support, we can call nextBuffer() from here
83 // instead of using onFrameAvailable(). No real benefit, except it'll be
84 // more like VirtualDisplaySurface.
88 status_t FramebufferSurface::nextBuffer(sp<GraphicBuffer>& outBuffer, sp<Fence>& outFence) {
89 Mutex::Autolock lock(mMutex);
92 status_t err = acquireBufferLocked(&item, 0);
93 if (err == BufferQueue::NO_BUFFER_AVAILABLE) {
94 outBuffer = mCurrentBuffer;
96 } else if (err != NO_ERROR) {
97 ALOGE("error acquiring buffer: %s (%d)", strerror(-err), err);
101 // If the BufferQueue has freed and reallocated a buffer in mCurrentSlot
102 // then we may have acquired the slot we already own. If we had released
103 // our current buffer before we call acquireBuffer then that release call
104 // would have returned STALE_BUFFER_SLOT, and we would have called
105 // freeBufferLocked on that slot. Because the buffer slot has already
106 // been overwritten with the new buffer all we have to do is skip the
107 // releaseBuffer call and we should be in the same state we'd be in if we
108 // had released the old buffer first.
109 if (mCurrentBufferSlot != BufferQueue::INVALID_BUFFER_SLOT &&
110 item.mBuf != mCurrentBufferSlot) {
111 // Release the previous buffer.
112 err = releaseBufferLocked(mCurrentBufferSlot, mCurrentBuffer,
113 EGL_NO_DISPLAY, EGL_NO_SYNC_KHR);
114 if (err < NO_ERROR) {
115 ALOGE("error releasing buffer: %s (%d)", strerror(-err), err);
119 mCurrentBufferSlot = item.mBuf;
120 mCurrentBuffer = mSlots[mCurrentBufferSlot].mGraphicBuffer;
121 outFence = item.mFence;
122 outBuffer = mCurrentBuffer;
126 // Overrides ConsumerBase::onFrameAvailable(), does not call base class impl.
127 void FramebufferSurface::onFrameAvailable(const BufferItem& /* item */) {
128 sp<GraphicBuffer> buf;
129 sp<Fence> acquireFence;
130 status_t err = nextBuffer(buf, acquireFence);
131 if (err != NO_ERROR) {
132 ALOGE("error latching nnext FramebufferSurface buffer: %s (%d)",
133 strerror(-err), err);
136 err = mHwc.fbPost(mDisplayType, acquireFence, buf);
137 if (err != NO_ERROR) {
138 ALOGE("error posting framebuffer: %d", err);
142 void FramebufferSurface::freeBufferLocked(int slotIndex) {
143 ConsumerBase::freeBufferLocked(slotIndex);
144 if (slotIndex == mCurrentBufferSlot) {
145 mCurrentBufferSlot = BufferQueue::INVALID_BUFFER_SLOT;
149 void FramebufferSurface::onFrameCommitted() {
150 sp<Fence> fence = mHwc.getAndResetReleaseFence(mDisplayType);
151 if (fence->isValid() &&
152 mCurrentBufferSlot != BufferQueue::INVALID_BUFFER_SLOT) {
153 status_t err = addReleaseFence(mCurrentBufferSlot,
154 mCurrentBuffer, fence);
155 ALOGE_IF(err, "setReleaseFenceFd: failed to add the fence: %s (%d)",
156 strerror(-err), err);
160 status_t FramebufferSurface::compositionComplete()
162 return mHwc.fbCompositionComplete();
165 void FramebufferSurface::dumpAsString(String8& result) const {
166 ConsumerBase::dump(result);
169 void FramebufferSurface::dumpLocked(String8& result, const char* prefix) const
172 ConsumerBase::dumpLocked(result, prefix);
175 // ----------------------------------------------------------------------------
176 }; // namespace android
177 // ----------------------------------------------------------------------------