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
49 namespace android {
50
51 // Get an ID that's unique within this process.
createProcessUniqueId()52 static int32_t createProcessUniqueId() {
53 static volatile int32_t globalCounter = 0;
54 return android_atomic_inc(&globalCounter);
55 }
56
ConsumerBase(const sp<IGraphicBufferConsumer> & bufferQueue,bool controlledByApp)57 ConsumerBase::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
~ConsumerBase()79 ConsumerBase::~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
onLastStrongRef(const void * id)91 void ConsumerBase::onLastStrongRef(const void* id __attribute__((unused))) {
92 abandon();
93 }
94
freeBufferLocked(int slotIndex)95 void 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
onFrameAvailable(const BufferItem & item)102 void 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
onFrameReplaced(const BufferItem & item)117 void 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
onBuffersReleased()132 void 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
onSidebandStreamChanged()151 void ConsumerBase::onSidebandStreamChanged() {
152 }
153
abandon()154 void ConsumerBase::abandon() {
155 CB_LOGV("abandon");
156 Mutex::Autolock lock(mMutex);
157
158 if (!mAbandoned) {
159 abandonLocked();
160 mAbandoned = true;
161 }
162 }
163
abandonLocked()164 void 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
isAbandoned()178 bool ConsumerBase::isAbandoned() {
179 Mutex::Autolock _l(mMutex);
180 return mAbandoned;
181 }
182
setFrameAvailableListener(const wp<FrameAvailableListener> & listener)183 void ConsumerBase::setFrameAvailableListener(
184 const wp<FrameAvailableListener>& listener) {
185 CB_LOGV("setFrameAvailableListener");
186 Mutex::Autolock lock(mMutex);
187 mFrameAvailableListener = listener;
188 }
189
detachBuffer(int slot)190 status_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
setDefaultBufferSize(uint32_t width,uint32_t height)210 status_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
setDefaultBufferFormat(PixelFormat defaultFormat)219 status_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
setDefaultBufferDataSpace(android_dataspace defaultDataSpace)228 status_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
dump(String8 & result) const238 void ConsumerBase::dump(String8& result) const {
239 dump(result, "");
240 }
241
dump(String8 & result,const char * prefix) const242 void ConsumerBase::dump(String8& result, const char* prefix) const {
243 Mutex::Autolock _l(mMutex);
244 dumpLocked(result, prefix);
245 }
246
dumpLocked(String8 & result,const char * prefix) const247 void ConsumerBase::dumpLocked(String8& result, const char* prefix) const {
248 result.appendFormat("%smAbandoned=%d\n", prefix, int(mAbandoned));
249
250 if (!mAbandoned) {
251 mConsumer->dump(result, prefix);
252 }
253 }
254
acquireBufferLocked(BufferItem * item,nsecs_t presentWhen,uint64_t maxFrameNumber)255 status_t ConsumerBase::acquireBufferLocked(BufferItem *item,
256 nsecs_t presentWhen, uint64_t maxFrameNumber) {
257 if (mAbandoned) {
258 CB_LOGE("acquireBufferLocked: ConsumerBase is abandoned!");
259 return NO_INIT;
260 }
261
262 status_t err = mConsumer->acquireBuffer(item, presentWhen, maxFrameNumber);
263 if (err != NO_ERROR) {
264 return err;
265 }
266
267 if (item->mGraphicBuffer != NULL) {
268 mSlots[item->mSlot].mGraphicBuffer = item->mGraphicBuffer;
269 }
270
271 mSlots[item->mSlot].mFrameNumber = item->mFrameNumber;
272 mSlots[item->mSlot].mFence = item->mFence;
273
274 CB_LOGV("acquireBufferLocked: -> slot=%d/%" PRIu64,
275 item->mSlot, item->mFrameNumber);
276
277 return OK;
278 }
279
addReleaseFence(int slot,const sp<GraphicBuffer> graphicBuffer,const sp<Fence> & fence)280 status_t ConsumerBase::addReleaseFence(int slot,
281 const sp<GraphicBuffer> graphicBuffer, const sp<Fence>& fence) {
282 Mutex::Autolock lock(mMutex);
283 return addReleaseFenceLocked(slot, graphicBuffer, fence);
284 }
285
addReleaseFenceLocked(int slot,const sp<GraphicBuffer> graphicBuffer,const sp<Fence> & fence)286 status_t ConsumerBase::addReleaseFenceLocked(int slot,
287 const sp<GraphicBuffer> graphicBuffer, const sp<Fence>& fence) {
288 CB_LOGV("addReleaseFenceLocked: slot=%d", slot);
289
290 // If consumer no longer tracks this graphicBuffer, we can safely
291 // drop this fence, as it will never be received by the producer.
292 if (!stillTracking(slot, graphicBuffer)) {
293 return OK;
294 }
295
296 if (!mSlots[slot].mFence.get()) {
297 mSlots[slot].mFence = fence;
298 } else {
299 sp<Fence> mergedFence = Fence::merge(
300 String8::format("%.28s:%d", mName.string(), slot),
301 mSlots[slot].mFence, fence);
302 if (!mergedFence.get()) {
303 CB_LOGE("failed to merge release fences");
304 // synchronization is broken, the best we can do is hope fences
305 // signal in order so the new fence will act like a union
306 mSlots[slot].mFence = fence;
307 return BAD_VALUE;
308 }
309 mSlots[slot].mFence = mergedFence;
310 }
311
312 return OK;
313 }
314
releaseBufferLocked(int slot,const sp<GraphicBuffer> graphicBuffer,EGLDisplay display,EGLSyncKHR eglFence)315 status_t ConsumerBase::releaseBufferLocked(
316 int slot, const sp<GraphicBuffer> graphicBuffer,
317 EGLDisplay display, EGLSyncKHR eglFence) {
318 if (mAbandoned) {
319 CB_LOGE("releaseBufferLocked: ConsumerBase is abandoned!");
320 return NO_INIT;
321 }
322 // If consumer no longer tracks this graphicBuffer (we received a new
323 // buffer on the same slot), the buffer producer is definitely no longer
324 // tracking it.
325 if (!stillTracking(slot, graphicBuffer)) {
326 return OK;
327 }
328
329 CB_LOGV("releaseBufferLocked: slot=%d/%" PRIu64,
330 slot, mSlots[slot].mFrameNumber);
331 status_t err = mConsumer->releaseBuffer(slot, mSlots[slot].mFrameNumber,
332 display, eglFence, mSlots[slot].mFence);
333 if (err == IGraphicBufferConsumer::STALE_BUFFER_SLOT) {
334 freeBufferLocked(slot);
335 }
336
337 mSlots[slot].mFence = Fence::NO_FENCE;
338
339 return err;
340 }
341
stillTracking(int slot,const sp<GraphicBuffer> graphicBuffer)342 bool ConsumerBase::stillTracking(int slot,
343 const sp<GraphicBuffer> graphicBuffer) {
344 if (slot < 0 || slot >= BufferQueue::NUM_BUFFER_SLOTS) {
345 return false;
346 }
347 return (mSlots[slot].mGraphicBuffer != NULL &&
348 mSlots[slot].mGraphicBuffer->handle == graphicBuffer->handle);
349 }
350
351 } // namespace android
352