FramebufferSurface.cpp revision f5a33928349bebc8eebc9f466618997e98c24e68
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#include <stdlib.h> 19#include <stdio.h> 20#include <string.h> 21#include <errno.h> 22 23#include <cutils/log.h> 24 25#include <utils/String8.h> 26 27#include <ui/Rect.h> 28 29#include <EGL/egl.h> 30 31#include <hardware/hardware.h> 32#include <gui/SurfaceTextureClient.h> 33#include <ui/GraphicBuffer.h> 34 35#include "DisplayHardware/FramebufferSurface.h" 36#include "DisplayHardware/GraphicBufferAlloc.h" 37#include "DisplayHardware/HWComposer.h" 38 39// ---------------------------------------------------------------------------- 40namespace android { 41// ---------------------------------------------------------------------------- 42 43/* 44 * This implements the (main) framebuffer management. This class is used 45 * mostly by SurfaceFlinger, but also by command line GL application. 46 * 47 */ 48 49FramebufferSurface::FramebufferSurface(HWComposer& hwc, int disp) : 50 ConsumerBase(new BufferQueue(true, new GraphicBufferAlloc())), 51 mDisplayType(disp), 52 mCurrentBufferSlot(-1), 53 mCurrentBuffer(0), 54 mHwc(hwc) 55{ 56 mName = "FramebufferSurface"; 57 mBufferQueue->setConsumerName(mName); 58 mBufferQueue->setConsumerUsageBits(GRALLOC_USAGE_HW_FB | 59 GRALLOC_USAGE_HW_RENDER | 60 GRALLOC_USAGE_HW_COMPOSER); 61 mBufferQueue->setDefaultBufferFormat(mHwc.getFormat(disp)); 62 mBufferQueue->setDefaultBufferSize(mHwc.getWidth(disp), mHwc.getHeight(disp)); 63 mBufferQueue->setSynchronousMode(true); 64 mBufferQueue->setDefaultMaxBufferCount(NUM_FRAME_BUFFERS); 65} 66 67status_t FramebufferSurface::nextBuffer(sp<GraphicBuffer>& outBuffer, sp<Fence>& outFence) { 68 Mutex::Autolock lock(mMutex); 69 70 BufferQueue::BufferItem item; 71 status_t err = acquireBufferLocked(&item); 72 if (err == BufferQueue::NO_BUFFER_AVAILABLE) { 73 outBuffer = mCurrentBuffer; 74 return NO_ERROR; 75 } else if (err != NO_ERROR) { 76 ALOGE("error acquiring buffer: %s (%d)", strerror(-err), err); 77 return err; 78 } 79 80 // If the BufferQueue has freed and reallocated a buffer in mCurrentSlot 81 // then we may have acquired the slot we already own. If we had released 82 // our current buffer before we call acquireBuffer then that release call 83 // would have returned STALE_BUFFER_SLOT, and we would have called 84 // freeBufferLocked on that slot. Because the buffer slot has already 85 // been overwritten with the new buffer all we have to do is skip the 86 // releaseBuffer call and we should be in the same state we'd be in if we 87 // had released the old buffer first. 88 if (mCurrentBufferSlot != BufferQueue::INVALID_BUFFER_SLOT && 89 item.mBuf != mCurrentBufferSlot) { 90 // Release the previous buffer. 91 err = releaseBufferLocked(mCurrentBufferSlot, EGL_NO_DISPLAY, 92 EGL_NO_SYNC_KHR); 93 if (err != NO_ERROR && err != BufferQueue::STALE_BUFFER_SLOT) { 94 ALOGE("error releasing buffer: %s (%d)", strerror(-err), err); 95 return err; 96 } 97 } 98 mCurrentBufferSlot = item.mBuf; 99 mCurrentBuffer = mSlots[mCurrentBufferSlot].mGraphicBuffer; 100 outFence = item.mFence; 101 outBuffer = mCurrentBuffer; 102 return NO_ERROR; 103} 104 105// Overrides ConsumerBase::onFrameAvailable(), does not call base class impl. 106void FramebufferSurface::onFrameAvailable() { 107 sp<GraphicBuffer> buf; 108 sp<Fence> acquireFence; 109 status_t err = nextBuffer(buf, acquireFence); 110 if (err != NO_ERROR) { 111 ALOGE("error latching nnext FramebufferSurface buffer: %s (%d)", 112 strerror(-err), err); 113 return; 114 } 115 err = mHwc.fbPost(mDisplayType, acquireFence, buf); 116 if (err != NO_ERROR) { 117 ALOGE("error posting framebuffer: %d", err); 118 } 119} 120 121void FramebufferSurface::freeBufferLocked(int slotIndex) { 122 ConsumerBase::freeBufferLocked(slotIndex); 123 if (slotIndex == mCurrentBufferSlot) { 124 mCurrentBufferSlot = BufferQueue::INVALID_BUFFER_SLOT; 125 } 126} 127 128status_t FramebufferSurface::setReleaseFenceFd(int fenceFd) { 129 status_t err = NO_ERROR; 130 if (fenceFd >= 0) { 131 sp<Fence> fence(new Fence(fenceFd)); 132 if (mCurrentBufferSlot != BufferQueue::INVALID_BUFFER_SLOT) { 133 status_t err = addReleaseFence(mCurrentBufferSlot, fence); 134 ALOGE_IF(err, "setReleaseFenceFd: failed to add the fence: %s (%d)", 135 strerror(-err), err); 136 } 137 } 138 return err; 139} 140 141status_t FramebufferSurface::setUpdateRectangle(const Rect& r) 142{ 143 return INVALID_OPERATION; 144} 145 146status_t FramebufferSurface::compositionComplete() 147{ 148 return mHwc.fbCompositionComplete(); 149} 150 151void FramebufferSurface::dump(String8& result) { 152 mHwc.fbDump(result); 153 ConsumerBase::dump(result); 154} 155 156// ---------------------------------------------------------------------------- 157}; // namespace android 158// ---------------------------------------------------------------------------- 159