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