ConsumerBase.cpp revision a34320a81c9787958f1b02e93e828472e54864b5
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/BufferItem.h> 31#include <gui/IGraphicBufferAlloc.h> 32#include <gui/ISurfaceComposer.h> 33#include <gui/SurfaceComposerClient.h> 34#include <gui/ConsumerBase.h> 35 36#include <private/gui/ComposerService.h> 37 38#include <utils/Log.h> 39#include <utils/String8.h> 40#include <utils/Trace.h> 41 42// Macros for including the ConsumerBase name in log messages 43#define CB_LOGV(x, ...) ALOGV("[%s] " x, mName.string(), ##__VA_ARGS__) 44//#define CB_LOGD(x, ...) ALOGD("[%s] " x, mName.string(), ##__VA_ARGS__) 45//#define CB_LOGI(x, ...) ALOGI("[%s] " x, mName.string(), ##__VA_ARGS__) 46//#define CB_LOGW(x, ...) ALOGW("[%s] " x, mName.string(), ##__VA_ARGS__) 47#define CB_LOGE(x, ...) ALOGE("[%s] " x, mName.string(), ##__VA_ARGS__) 48 49namespace android { 50 51// Get an ID that's unique within this process. 52static int32_t createProcessUniqueId() { 53 static volatile int32_t globalCounter = 0; 54 return android_atomic_inc(&globalCounter); 55} 56 57ConsumerBase::ConsumerBase(const sp<IGraphicBufferConsumer>& bufferQueue, bool controlledByApp) : 58 mAbandoned(false), 59 mConsumer(bufferQueue), 60 mPrevFinalReleaseFence(Fence::NO_FENCE) { 61 // Choose a name using the PID and a process-unique ID. 62 mName = String8::format("unnamed-%d-%d", getpid(), createProcessUniqueId()); 63 64 // Note that we can't create an sp<...>(this) in a ctor that will not keep a 65 // reference once the ctor ends, as that would cause the refcount of 'this' 66 // dropping to 0 at the end of the ctor. Since all we need is a wp<...> 67 // that's what we create. 68 wp<ConsumerListener> listener = static_cast<ConsumerListener*>(this); 69 sp<IConsumerListener> proxy = new BufferQueue::ProxyConsumerListener(listener); 70 71 status_t err = mConsumer->consumerConnect(proxy, controlledByApp); 72 if (err != NO_ERROR) { 73 CB_LOGE("ConsumerBase: error connecting to BufferQueue: %s (%d)", 74 strerror(-err), err); 75 } else { 76 mConsumer->setConsumerName(mName); 77 } 78} 79 80ConsumerBase::~ConsumerBase() { 81 CB_LOGV("~ConsumerBase"); 82 Mutex::Autolock lock(mMutex); 83 84 // Verify that abandon() has been called before we get here. This should 85 // be done by ConsumerBase::onLastStrongRef(), but it's possible for a 86 // derived class to override that method and not call 87 // ConsumerBase::onLastStrongRef(). 88 LOG_ALWAYS_FATAL_IF(!mAbandoned, "[%s] ~ConsumerBase was called, but the " 89 "consumer is not abandoned!", mName.string()); 90} 91 92void ConsumerBase::onLastStrongRef(const void* id __attribute__((unused))) { 93 abandon(); 94} 95 96void ConsumerBase::freeBufferLocked(int slotIndex) { 97 CB_LOGV("freeBufferLocked: slotIndex=%d", slotIndex); 98 mSlots[slotIndex].mGraphicBuffer = 0; 99 mSlots[slotIndex].mFence = Fence::NO_FENCE; 100 mSlots[slotIndex].mFrameNumber = 0; 101} 102 103void ConsumerBase::onFrameAvailable(const BufferItem& item) { 104 CB_LOGV("onFrameAvailable"); 105 106 sp<FrameAvailableListener> listener; 107 { // scope for the lock 108 Mutex::Autolock lock(mMutex); 109 listener = mFrameAvailableListener.promote(); 110 } 111 112 if (listener != NULL) { 113 CB_LOGV("actually calling onFrameAvailable"); 114 listener->onFrameAvailable(item); 115 } 116} 117 118void ConsumerBase::onFrameReplaced(const BufferItem &item) { 119 CB_LOGV("onFrameReplaced"); 120 121 sp<FrameAvailableListener> listener; 122 { 123 Mutex::Autolock lock(mMutex); 124 listener = mFrameAvailableListener.promote(); 125 } 126 127 if (listener != NULL) { 128 CB_LOGV("actually calling onFrameReplaced"); 129 listener->onFrameReplaced(item); 130 } 131} 132 133void ConsumerBase::onBuffersReleased() { 134 Mutex::Autolock lock(mMutex); 135 136 CB_LOGV("onBuffersReleased"); 137 138 if (mAbandoned) { 139 // Nothing to do if we're already abandoned. 140 return; 141 } 142 143 uint64_t mask = 0; 144 mConsumer->getReleasedBuffers(&mask); 145 for (int i = 0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) { 146 if (mask & (1ULL << i)) { 147 freeBufferLocked(i); 148 } 149 } 150} 151 152void ConsumerBase::onSidebandStreamChanged() { 153} 154 155void ConsumerBase::abandon() { 156 CB_LOGV("abandon"); 157 Mutex::Autolock lock(mMutex); 158 159 if (!mAbandoned) { 160 abandonLocked(); 161 mAbandoned = true; 162 } 163} 164 165void ConsumerBase::abandonLocked() { 166 CB_LOGV("abandonLocked"); 167 if (mAbandoned) { 168 CB_LOGE("abandonLocked: ConsumerBase is abandoned!"); 169 return; 170 } 171 for (int i =0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) { 172 freeBufferLocked(i); 173 } 174 // disconnect from the BufferQueue 175 mConsumer->consumerDisconnect(); 176 mConsumer.clear(); 177} 178 179bool ConsumerBase::isAbandoned() { 180 Mutex::Autolock _l(mMutex); 181 return mAbandoned; 182} 183 184void ConsumerBase::setFrameAvailableListener( 185 const wp<FrameAvailableListener>& listener) { 186 CB_LOGV("setFrameAvailableListener"); 187 Mutex::Autolock lock(mMutex); 188 mFrameAvailableListener = listener; 189} 190 191status_t ConsumerBase::detachBuffer(int slot) { 192 CB_LOGV("detachBuffer"); 193 Mutex::Autolock lock(mMutex); 194 195 if (mAbandoned) { 196 CB_LOGE("detachBuffer: ConsumerBase is abandoned!"); 197 return NO_INIT; 198 } 199 200 status_t result = mConsumer->detachBuffer(slot); 201 if (result != NO_ERROR) { 202 CB_LOGE("Failed to detach buffer: %d", result); 203 return result; 204 } 205 206 freeBufferLocked(slot); 207 208 return result; 209} 210 211status_t ConsumerBase::setDefaultBufferSize(uint32_t width, uint32_t height) { 212 Mutex::Autolock _l(mMutex); 213 if (mAbandoned) { 214 CB_LOGE("setDefaultBufferSize: ConsumerBase is abandoned!"); 215 return NO_INIT; 216 } 217 return mConsumer->setDefaultBufferSize(width, height); 218} 219 220status_t ConsumerBase::setDefaultBufferFormat(PixelFormat defaultFormat) { 221 Mutex::Autolock _l(mMutex); 222 if (mAbandoned) { 223 CB_LOGE("setDefaultBufferFormat: ConsumerBase is abandoned!"); 224 return NO_INIT; 225 } 226 return mConsumer->setDefaultBufferFormat(defaultFormat); 227} 228 229status_t ConsumerBase::setDefaultBufferDataSpace( 230 android_dataspace defaultDataSpace) { 231 Mutex::Autolock _l(mMutex); 232 if (mAbandoned) { 233 CB_LOGE("setDefaultBufferDataSpace: ConsumerBase is abandoned!"); 234 return NO_INIT; 235 } 236 return mConsumer->setDefaultBufferDataSpace(defaultDataSpace); 237} 238 239status_t ConsumerBase::getOccupancyHistory(bool forceFlush, 240 std::vector<OccupancyTracker::Segment>* outHistory) { 241 Mutex::Autolock _l(mMutex); 242 if (mAbandoned) { 243 CB_LOGE("getOccupancyHistory: ConsumerBase is abandoned!"); 244 return NO_INIT; 245 } 246 return mConsumer->getOccupancyHistory(forceFlush, outHistory); 247} 248 249status_t ConsumerBase::discardFreeBuffers() { 250 Mutex::Autolock _l(mMutex); 251 if (mAbandoned) { 252 CB_LOGE("discardFreeBuffers: ConsumerBase is abandoned!"); 253 return NO_INIT; 254 } 255 return mConsumer->discardFreeBuffers(); 256} 257 258void ConsumerBase::dumpState(String8& result) const { 259 dumpState(result, ""); 260} 261 262void ConsumerBase::dumpState(String8& result, const char* prefix) const { 263 Mutex::Autolock _l(mMutex); 264 dumpLocked(result, prefix); 265} 266 267void ConsumerBase::dumpLocked(String8& result, const char* prefix) const { 268 result.appendFormat("%smAbandoned=%d\n", prefix, int(mAbandoned)); 269 270 if (!mAbandoned) { 271 mConsumer->dumpState(result, prefix); 272 } 273} 274 275status_t ConsumerBase::acquireBufferLocked(BufferItem *item, 276 nsecs_t presentWhen, uint64_t maxFrameNumber) { 277 if (mAbandoned) { 278 CB_LOGE("acquireBufferLocked: ConsumerBase is abandoned!"); 279 return NO_INIT; 280 } 281 282 status_t err = mConsumer->acquireBuffer(item, presentWhen, maxFrameNumber); 283 if (err != NO_ERROR) { 284 return err; 285 } 286 287 if (item->mGraphicBuffer != NULL) { 288 mSlots[item->mSlot].mGraphicBuffer = item->mGraphicBuffer; 289 } 290 291 mSlots[item->mSlot].mFrameNumber = item->mFrameNumber; 292 mSlots[item->mSlot].mFence = item->mFence; 293 294 CB_LOGV("acquireBufferLocked: -> slot=%d/%" PRIu64, 295 item->mSlot, item->mFrameNumber); 296 297 return OK; 298} 299 300status_t ConsumerBase::addReleaseFence(int slot, 301 const sp<GraphicBuffer> graphicBuffer, const sp<Fence>& fence) { 302 Mutex::Autolock lock(mMutex); 303 return addReleaseFenceLocked(slot, graphicBuffer, fence); 304} 305 306status_t ConsumerBase::addReleaseFenceLocked(int slot, 307 const sp<GraphicBuffer> graphicBuffer, const sp<Fence>& fence) { 308 CB_LOGV("addReleaseFenceLocked: slot=%d", slot); 309 310 // If consumer no longer tracks this graphicBuffer, we can safely 311 // drop this fence, as it will never be received by the producer. 312 if (!stillTracking(slot, graphicBuffer)) { 313 return OK; 314 } 315 316 if (!mSlots[slot].mFence.get()) { 317 mSlots[slot].mFence = fence; 318 return OK; 319 } 320 321 auto status = mSlots[slot].mFence->getStatus(); 322 323 if (status == Fence::Status::Invalid) { 324 CB_LOGE("fence has invalid state"); 325 return BAD_VALUE; 326 } 327 328 if (status == Fence::Status::Signaled) { 329 mSlots[slot].mFence = fence; 330 } else { // status == Fence::Status::Unsignaled 331 char fenceName[32] = {}; 332 snprintf(fenceName, 32, "%.28s:%d", mName.string(), slot); 333 sp<Fence> mergedFence = Fence::merge( 334 fenceName, mSlots[slot].mFence, fence); 335 if (!mergedFence.get()) { 336 CB_LOGE("failed to merge release fences"); 337 // synchronization is broken, the best we can do is hope fences 338 // signal in order so the new fence will act like a union 339 mSlots[slot].mFence = fence; 340 return BAD_VALUE; 341 } 342 mSlots[slot].mFence = mergedFence; 343 } 344 345 return OK; 346} 347 348status_t ConsumerBase::releaseBufferLocked( 349 int slot, const sp<GraphicBuffer> graphicBuffer, 350 EGLDisplay display, EGLSyncKHR eglFence) { 351 if (mAbandoned) { 352 CB_LOGE("releaseBufferLocked: ConsumerBase is abandoned!"); 353 return NO_INIT; 354 } 355 // If consumer no longer tracks this graphicBuffer (we received a new 356 // buffer on the same slot), the buffer producer is definitely no longer 357 // tracking it. 358 if (!stillTracking(slot, graphicBuffer)) { 359 return OK; 360 } 361 362 CB_LOGV("releaseBufferLocked: slot=%d/%" PRIu64, 363 slot, mSlots[slot].mFrameNumber); 364 status_t err = mConsumer->releaseBuffer(slot, mSlots[slot].mFrameNumber, 365 display, eglFence, mSlots[slot].mFence); 366 if (err == IGraphicBufferConsumer::STALE_BUFFER_SLOT) { 367 freeBufferLocked(slot); 368 } 369 370 mPrevFinalReleaseFence = mSlots[slot].mFence; 371 mSlots[slot].mFence = Fence::NO_FENCE; 372 373 return err; 374} 375 376bool ConsumerBase::stillTracking(int slot, 377 const sp<GraphicBuffer> graphicBuffer) { 378 if (slot < 0 || slot >= BufferQueue::NUM_BUFFER_SLOTS) { 379 return false; 380 } 381 return (mSlots[slot].mGraphicBuffer != NULL && 382 mSlots[slot].mGraphicBuffer->handle == graphicBuffer->handle); 383} 384 385} // namespace android 386