1 /* 2 * Copyright (C) 2010 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 LOG_TAG "ConsumerBase" 18 #define ATRACE_TAG ATRACE_TAG_GRAPHICS 19 //#define LOG_NDEBUG 0 20 21 #define EGL_EGLEXT_PROTOTYPES 22 23 #include <EGL/egl.h> 24 #include <EGL/eglext.h> 25 26 #include <hardware/hardware.h> 27 28 #include <gui/IGraphicBufferAlloc.h> 29 #include <gui/ISurfaceComposer.h> 30 #include <gui/SurfaceComposerClient.h> 31 #include <gui/ConsumerBase.h> 32 33 #include <private/gui/ComposerService.h> 34 35 #include <utils/Log.h> 36 #include <utils/String8.h> 37 #include <utils/Trace.h> 38 39 // Macros for including the ConsumerBase name in log messages 40 #define CB_LOGV(x, ...) ALOGV("[%s] "x, mName.string(), ##__VA_ARGS__) 41 #define CB_LOGD(x, ...) ALOGD("[%s] "x, mName.string(), ##__VA_ARGS__) 42 #define CB_LOGI(x, ...) ALOGI("[%s] "x, mName.string(), ##__VA_ARGS__) 43 #define CB_LOGW(x, ...) ALOGW("[%s] "x, mName.string(), ##__VA_ARGS__) 44 #define CB_LOGE(x, ...) ALOGE("[%s] "x, mName.string(), ##__VA_ARGS__) 45 46 namespace android { 47 48 // Get an ID that's unique within this process. 49 static int32_t createProcessUniqueId() { 50 static volatile int32_t globalCounter = 0; 51 return android_atomic_inc(&globalCounter); 52 } 53 54 ConsumerBase::ConsumerBase(const sp<IGraphicBufferConsumer>& bufferQueue, bool controlledByApp) : 55 mAbandoned(false), 56 mConsumer(bufferQueue) { 57 // Choose a name using the PID and a process-unique ID. 58 mName = String8::format("unnamed-%d-%d", getpid(), createProcessUniqueId()); 59 60 // Note that we can't create an sp<...>(this) in a ctor that will not keep a 61 // reference once the ctor ends, as that would cause the refcount of 'this' 62 // dropping to 0 at the end of the ctor. Since all we need is a wp<...> 63 // that's what we create. 64 wp<ConsumerListener> listener = static_cast<ConsumerListener*>(this); 65 sp<IConsumerListener> proxy = new BufferQueue::ProxyConsumerListener(listener); 66 67 status_t err = mConsumer->consumerConnect(proxy, controlledByApp); 68 if (err != NO_ERROR) { 69 CB_LOGE("ConsumerBase: error connecting to BufferQueue: %s (%d)", 70 strerror(-err), err); 71 } else { 72 mConsumer->setConsumerName(mName); 73 } 74 } 75 76 ConsumerBase::~ConsumerBase() { 77 CB_LOGV("~ConsumerBase"); 78 Mutex::Autolock lock(mMutex); 79 80 // Verify that abandon() has been called before we get here. This should 81 // be done by ConsumerBase::onLastStrongRef(), but it's possible for a 82 // derived class to override that method and not call 83 // ConsumerBase::onLastStrongRef(). 84 LOG_ALWAYS_FATAL_IF(!mAbandoned, "[%s] ~ConsumerBase was called, but the " 85 "consumer is not abandoned!", mName.string()); 86 } 87 88 void ConsumerBase::onLastStrongRef(const void* id) { 89 abandon(); 90 } 91 92 void ConsumerBase::freeBufferLocked(int slotIndex) { 93 CB_LOGV("freeBufferLocked: slotIndex=%d", slotIndex); 94 mSlots[slotIndex].mGraphicBuffer = 0; 95 mSlots[slotIndex].mFence = Fence::NO_FENCE; 96 mSlots[slotIndex].mFrameNumber = 0; 97 } 98 99 void ConsumerBase::onFrameAvailable() { 100 CB_LOGV("onFrameAvailable"); 101 102 sp<FrameAvailableListener> listener; 103 { // scope for the lock 104 Mutex::Autolock lock(mMutex); 105 listener = mFrameAvailableListener.promote(); 106 } 107 108 if (listener != NULL) { 109 CB_LOGV("actually calling onFrameAvailable"); 110 listener->onFrameAvailable(); 111 } 112 } 113 114 void ConsumerBase::onBuffersReleased() { 115 Mutex::Autolock lock(mMutex); 116 117 CB_LOGV("onBuffersReleased"); 118 119 if (mAbandoned) { 120 // Nothing to do if we're already abandoned. 121 return; 122 } 123 124 uint32_t mask = 0; 125 mConsumer->getReleasedBuffers(&mask); 126 for (int i = 0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) { 127 if (mask & (1 << i)) { 128 freeBufferLocked(i); 129 } 130 } 131 } 132 133 void ConsumerBase::abandon() { 134 CB_LOGV("abandon"); 135 Mutex::Autolock lock(mMutex); 136 137 if (!mAbandoned) { 138 abandonLocked(); 139 mAbandoned = true; 140 } 141 } 142 143 void ConsumerBase::abandonLocked() { 144 CB_LOGV("abandonLocked"); 145 for (int i =0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) { 146 freeBufferLocked(i); 147 } 148 // disconnect from the BufferQueue 149 mConsumer->consumerDisconnect(); 150 mConsumer.clear(); 151 } 152 153 void ConsumerBase::setFrameAvailableListener( 154 const wp<FrameAvailableListener>& listener) { 155 CB_LOGV("setFrameAvailableListener"); 156 Mutex::Autolock lock(mMutex); 157 mFrameAvailableListener = listener; 158 } 159 160 void ConsumerBase::dump(String8& result) const { 161 dump(result, ""); 162 } 163 164 void ConsumerBase::dump(String8& result, const char* prefix) const { 165 Mutex::Autolock _l(mMutex); 166 dumpLocked(result, prefix); 167 } 168 169 void ConsumerBase::dumpLocked(String8& result, const char* prefix) const { 170 result.appendFormat("%smAbandoned=%d\n", prefix, int(mAbandoned)); 171 172 if (!mAbandoned) { 173 mConsumer->dump(result, prefix); 174 } 175 } 176 177 status_t ConsumerBase::acquireBufferLocked(BufferQueue::BufferItem *item, 178 nsecs_t presentWhen) { 179 status_t err = mConsumer->acquireBuffer(item, presentWhen); 180 if (err != NO_ERROR) { 181 return err; 182 } 183 184 if (item->mGraphicBuffer != NULL) { 185 mSlots[item->mBuf].mGraphicBuffer = item->mGraphicBuffer; 186 } 187 188 mSlots[item->mBuf].mFrameNumber = item->mFrameNumber; 189 mSlots[item->mBuf].mFence = item->mFence; 190 191 CB_LOGV("acquireBufferLocked: -> slot=%d/%llu", 192 item->mBuf, item->mFrameNumber); 193 194 return OK; 195 } 196 197 status_t ConsumerBase::addReleaseFence(int slot, 198 const sp<GraphicBuffer> graphicBuffer, const sp<Fence>& fence) { 199 Mutex::Autolock lock(mMutex); 200 return addReleaseFenceLocked(slot, graphicBuffer, fence); 201 } 202 203 status_t ConsumerBase::addReleaseFenceLocked(int slot, 204 const sp<GraphicBuffer> graphicBuffer, const sp<Fence>& fence) { 205 CB_LOGV("addReleaseFenceLocked: slot=%d", slot); 206 207 // If consumer no longer tracks this graphicBuffer, we can safely 208 // drop this fence, as it will never be received by the producer. 209 if (!stillTracking(slot, graphicBuffer)) { 210 return OK; 211 } 212 213 if (!mSlots[slot].mFence.get()) { 214 mSlots[slot].mFence = fence; 215 } else { 216 sp<Fence> mergedFence = Fence::merge( 217 String8::format("%.28s:%d", mName.string(), slot), 218 mSlots[slot].mFence, fence); 219 if (!mergedFence.get()) { 220 CB_LOGE("failed to merge release fences"); 221 // synchronization is broken, the best we can do is hope fences 222 // signal in order so the new fence will act like a union 223 mSlots[slot].mFence = fence; 224 return BAD_VALUE; 225 } 226 mSlots[slot].mFence = mergedFence; 227 } 228 229 return OK; 230 } 231 232 status_t ConsumerBase::releaseBufferLocked( 233 int slot, const sp<GraphicBuffer> graphicBuffer, 234 EGLDisplay display, EGLSyncKHR eglFence) { 235 // If consumer no longer tracks this graphicBuffer (we received a new 236 // buffer on the same slot), the buffer producer is definitely no longer 237 // tracking it. 238 if (!stillTracking(slot, graphicBuffer)) { 239 return OK; 240 } 241 242 CB_LOGV("releaseBufferLocked: slot=%d/%llu", 243 slot, mSlots[slot].mFrameNumber); 244 status_t err = mConsumer->releaseBuffer(slot, mSlots[slot].mFrameNumber, 245 display, eglFence, mSlots[slot].mFence); 246 if (err == BufferQueue::STALE_BUFFER_SLOT) { 247 freeBufferLocked(slot); 248 } 249 250 mSlots[slot].mFence = Fence::NO_FENCE; 251 252 return err; 253 } 254 255 bool ConsumerBase::stillTracking(int slot, 256 const sp<GraphicBuffer> graphicBuffer) { 257 if (slot < 0 || slot >= BufferQueue::NUM_BUFFER_SLOTS) { 258 return false; 259 } 260 return (mSlots[slot].mGraphicBuffer != NULL && 261 mSlots[slot].mGraphicBuffer->handle == graphicBuffer->handle); 262 } 263 264 } // namespace android 265
