FramebufferSurface.cpp revision 9e56aa0fdb5f7121b9b975c6c16db103ea4d2fe9
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// ---------------------------------------------------------------------------- 49namespace 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 58FramebufferSurface::FramebufferSurface(HWComposer& hwc, int disp, 59 const sp<IGraphicBufferConsumer>& consumer) : 60 ConsumerBase(consumer), 61 mDisplayType(disp), 62 mCurrentBufferSlot(-1), 63#ifdef USE_HWC2 64 mCurrentBuffer(), 65 mCurrentFence(Fence::NO_FENCE), 66 mHwc(hwc), 67 mHasPendingRelease(false), 68 mPreviousBufferSlot(BufferQueue::INVALID_BUFFER_SLOT), 69 mPreviousBuffer() 70#else 71 mCurrentBuffer(0), 72 mHwc(hwc) 73#endif 74{ 75#ifdef USE_HWC2 76 ALOGV("Creating for display %d", disp); 77#endif 78 79 mName = "FramebufferSurface"; 80 mConsumer->setConsumerName(mName); 81 mConsumer->setConsumerUsageBits(GRALLOC_USAGE_HW_FB | 82 GRALLOC_USAGE_HW_RENDER | 83 GRALLOC_USAGE_HW_COMPOSER); 84#ifdef USE_HWC2 85 const auto& activeConfig = mHwc.getActiveConfig(disp); 86 mConsumer->setDefaultBufferSize(activeConfig->getWidth(), 87 activeConfig->getHeight()); 88#else 89 mConsumer->setDefaultBufferFormat(mHwc.getFormat(disp)); 90 mConsumer->setDefaultBufferSize(mHwc.getWidth(disp), mHwc.getHeight(disp)); 91#endif 92 mConsumer->setMaxAcquiredBufferCount(NUM_FRAMEBUFFER_SURFACE_BUFFERS - 1); 93} 94 95status_t FramebufferSurface::beginFrame(bool /*mustRecompose*/) { 96 return NO_ERROR; 97} 98 99status_t FramebufferSurface::prepareFrame(CompositionType /*compositionType*/) { 100 return NO_ERROR; 101} 102 103status_t FramebufferSurface::advanceFrame() { 104#ifdef USE_HWC2 105 sp<GraphicBuffer> buf; 106 sp<Fence> acquireFence(Fence::NO_FENCE); 107 android_dataspace_t dataspace = HAL_DATASPACE_UNKNOWN; 108 status_t result = nextBuffer(buf, acquireFence, dataspace); 109 if (result != NO_ERROR) { 110 ALOGE("error latching next FramebufferSurface buffer: %s (%d)", 111 strerror(-result), result); 112 return result; 113 } 114 result = mHwc.setClientTarget(mDisplayType, acquireFence, buf, dataspace); 115 if (result != NO_ERROR) { 116 ALOGE("error posting framebuffer: %d", result); 117 } 118 return result; 119#else 120 // Once we remove FB HAL support, we can call nextBuffer() from here 121 // instead of using onFrameAvailable(). No real benefit, except it'll be 122 // more like VirtualDisplaySurface. 123 return NO_ERROR; 124#endif 125} 126 127#ifdef USE_HWC2 128status_t FramebufferSurface::nextBuffer(sp<GraphicBuffer>& outBuffer, 129 sp<Fence>& outFence, android_dataspace_t& outDataspace) { 130#else 131status_t FramebufferSurface::nextBuffer(sp<GraphicBuffer>& outBuffer, sp<Fence>& outFence) { 132#endif 133 Mutex::Autolock lock(mMutex); 134 135 BufferItem item; 136 status_t err = acquireBufferLocked(&item, 0); 137 if (err == BufferQueue::NO_BUFFER_AVAILABLE) { 138 outBuffer = mCurrentBuffer; 139 return NO_ERROR; 140 } else if (err != NO_ERROR) { 141 ALOGE("error acquiring buffer: %s (%d)", strerror(-err), err); 142 return err; 143 } 144 145 // If the BufferQueue has freed and reallocated a buffer in mCurrentSlot 146 // then we may have acquired the slot we already own. If we had released 147 // our current buffer before we call acquireBuffer then that release call 148 // would have returned STALE_BUFFER_SLOT, and we would have called 149 // freeBufferLocked on that slot. Because the buffer slot has already 150 // been overwritten with the new buffer all we have to do is skip the 151 // releaseBuffer call and we should be in the same state we'd be in if we 152 // had released the old buffer first. 153 if (mCurrentBufferSlot != BufferQueue::INVALID_BUFFER_SLOT && 154 item.mSlot != mCurrentBufferSlot) { 155#ifdef USE_HWC2 156 mHasPendingRelease = true; 157 mPreviousBufferSlot = mCurrentBufferSlot; 158 mPreviousBuffer = mCurrentBuffer; 159#else 160 // Release the previous buffer. 161 err = releaseBufferLocked(mCurrentBufferSlot, mCurrentBuffer, 162 EGL_NO_DISPLAY, EGL_NO_SYNC_KHR); 163 if (err < NO_ERROR) { 164 ALOGE("error releasing buffer: %s (%d)", strerror(-err), err); 165 return err; 166 } 167#endif 168 } 169 mCurrentBufferSlot = item.mSlot; 170 mCurrentBuffer = mSlots[mCurrentBufferSlot].mGraphicBuffer; 171#ifdef USE_HWC2 172 mCurrentFence = item.mFence; 173#endif 174 175 outFence = item.mFence; 176 outBuffer = mCurrentBuffer; 177#ifdef USE_HWC2 178 outDataspace = item.mDataSpace; 179#endif 180 return NO_ERROR; 181} 182 183#ifndef USE_HWC2 184// Overrides ConsumerBase::onFrameAvailable(), does not call base class impl. 185void FramebufferSurface::onFrameAvailable(const BufferItem& /* item */) { 186 sp<GraphicBuffer> buf; 187 sp<Fence> acquireFence; 188 status_t err = nextBuffer(buf, acquireFence); 189 if (err != NO_ERROR) { 190 ALOGE("error latching nnext FramebufferSurface buffer: %s (%d)", 191 strerror(-err), err); 192 return; 193 } 194 err = mHwc.fbPost(mDisplayType, acquireFence, buf); 195 if (err != NO_ERROR) { 196 ALOGE("error posting framebuffer: %d", err); 197 } 198} 199#endif 200 201void FramebufferSurface::freeBufferLocked(int slotIndex) { 202 ConsumerBase::freeBufferLocked(slotIndex); 203 if (slotIndex == mCurrentBufferSlot) { 204 mCurrentBufferSlot = BufferQueue::INVALID_BUFFER_SLOT; 205 } 206} 207 208void FramebufferSurface::onFrameCommitted() { 209#ifdef USE_HWC2 210 if (mHasPendingRelease) { 211 sp<Fence> fence = mHwc.getRetireFence(mDisplayType); 212 if (fence->isValid()) { 213 status_t result = addReleaseFence(mPreviousBufferSlot, 214 mPreviousBuffer, fence); 215 ALOGE_IF(result != NO_ERROR, "onFrameCommitted: failed to add the" 216 " fence: %s (%d)", strerror(-result), result); 217 } 218 status_t result = releaseBufferLocked(mPreviousBufferSlot, 219 mPreviousBuffer, EGL_NO_DISPLAY, EGL_NO_SYNC_KHR); 220 ALOGE_IF(result != NO_ERROR, "onFrameCommitted: error releasing buffer:" 221 " %s (%d)", strerror(-result), result); 222 223 mPreviousBuffer.clear(); 224 mHasPendingRelease = false; 225 } 226#else 227 sp<Fence> fence = mHwc.getAndResetReleaseFence(mDisplayType); 228 if (fence->isValid() && 229 mCurrentBufferSlot != BufferQueue::INVALID_BUFFER_SLOT) { 230 status_t err = addReleaseFence(mCurrentBufferSlot, 231 mCurrentBuffer, fence); 232 ALOGE_IF(err, "setReleaseFenceFd: failed to add the fence: %s (%d)", 233 strerror(-err), err); 234 } 235#endif 236} 237 238#ifndef USE_HWC2 239status_t FramebufferSurface::compositionComplete() 240{ 241 return mHwc.fbCompositionComplete(); 242} 243#endif 244 245void FramebufferSurface::dumpAsString(String8& result) const { 246 ConsumerBase::dump(result); 247} 248 249void FramebufferSurface::dumpLocked(String8& result, const char* prefix) const 250{ 251#ifndef USE_HWC2 252 mHwc.fbDump(result); 253#endif 254 ConsumerBase::dumpLocked(result, prefix); 255} 256 257#ifdef USE_HWC2 258const sp<Fence>& FramebufferSurface::getClientTargetAcquireFence() const { 259 return mCurrentFence; 260} 261#endif 262 263// ---------------------------------------------------------------------------- 264}; // namespace android 265// ---------------------------------------------------------------------------- 266