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