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