2 * Copyright (C) 2012 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 //#define LOG_NDEBUG 0
18 #define LOG_TAG "CpuConsumer"
19 //#define ATRACE_TAG ATRACE_TAG_GRAPHICS
21 #include <cutils/compiler.h>
22 #include <utils/Log.h>
23 #include <gui/CpuConsumer.h>
25 //#define CC_LOGV(x, ...) ALOGV("[%s] " x, mName.string(), ##__VA_ARGS__)
26 //#define CC_LOGD(x, ...) ALOGD("[%s] " x, mName.string(), ##__VA_ARGS__)
27 //#define CC_LOGI(x, ...) ALOGI("[%s] " x, mName.string(), ##__VA_ARGS__)
28 #define CC_LOGW(x, ...) ALOGW("[%s] " x, mName.string(), ##__VA_ARGS__)
29 #define CC_LOGE(x, ...) ALOGE("[%s] " x, mName.string(), ##__VA_ARGS__)
33 CpuConsumer::CpuConsumer(const sp<IGraphicBufferConsumer>& bq,
34 size_t maxLockedBuffers, bool controlledByApp) :
35 ConsumerBase(bq, controlledByApp),
36 mMaxLockedBuffers(maxLockedBuffers),
37 mCurrentLockedBuffers(0)
39 // Create tracking entries for locked buffers
40 mAcquiredBuffers.insertAt(0, maxLockedBuffers);
42 mConsumer->setConsumerUsageBits(GRALLOC_USAGE_SW_READ_OFTEN);
43 mConsumer->setMaxAcquiredBufferCount(static_cast<int32_t>(maxLockedBuffers));
46 CpuConsumer::~CpuConsumer() {
47 // ConsumerBase destructor does all the work.
52 void CpuConsumer::setName(const String8& name) {
53 Mutex::Autolock _l(mMutex);
55 mConsumer->setConsumerName(name);
58 status_t CpuConsumer::setDefaultBufferSize(uint32_t width, uint32_t height)
60 Mutex::Autolock _l(mMutex);
61 return mConsumer->setDefaultBufferSize(width, height);
64 status_t CpuConsumer::setDefaultBufferFormat(PixelFormat defaultFormat)
66 Mutex::Autolock _l(mMutex);
67 return mConsumer->setDefaultBufferFormat(defaultFormat);
70 status_t CpuConsumer::lockNextBuffer(LockedBuffer *nativeBuffer) {
73 if (!nativeBuffer) return BAD_VALUE;
74 if (mCurrentLockedBuffers == mMaxLockedBuffers) {
75 CC_LOGW("Max buffers have been locked (%zd), cannot lock anymore.",
77 return NOT_ENOUGH_DATA;
80 BufferQueue::BufferItem b;
82 Mutex::Autolock _l(mMutex);
84 err = acquireBufferLocked(&b, 0);
86 if (err == BufferQueue::NO_BUFFER_AVAILABLE) {
89 CC_LOGE("Error acquiring buffer: %s (%d)", strerror(err), err);
96 void *bufferPointer = NULL;
97 android_ycbcr ycbcr = android_ycbcr();
100 if (mSlots[buf].mGraphicBuffer->getPixelFormat() ==
101 HAL_PIXEL_FORMAT_YCbCr_420_888) {
102 err = mSlots[buf].mGraphicBuffer->lockAsyncYCbCr(
103 GraphicBuffer::USAGE_SW_READ_OFTEN,
109 CC_LOGE("Unable to lock YCbCr buffer for CPU reading: %s (%d)",
110 strerror(-err), err);
113 bufferPointer = ycbcr.y;
115 err = mSlots[buf].mGraphicBuffer->lockAsync(
116 GraphicBuffer::USAGE_SW_READ_OFTEN,
122 CC_LOGE("Unable to lock buffer for CPU reading: %s (%d)",
123 strerror(-err), err);
128 if (mSlots[buf].mGraphicBuffer->getPixelFormat() ==
129 HAL_PIXEL_FORMAT_YCbCr_420_888) {
130 err = mSlots[buf].mGraphicBuffer->lockYCbCr(
131 GraphicBuffer::USAGE_SW_READ_OFTEN,
136 CC_LOGE("Unable to lock YCbCr buffer for CPU reading: %s (%d)",
137 strerror(-err), err);
140 bufferPointer = ycbcr.y;
142 err = mSlots[buf].mGraphicBuffer->lock(
143 GraphicBuffer::USAGE_SW_READ_OFTEN,
148 CC_LOGE("Unable to lock buffer for CPU reading: %s (%d)",
149 strerror(-err), err);
155 size_t lockedIdx = 0;
156 for (; lockedIdx < static_cast<size_t>(mMaxLockedBuffers); lockedIdx++) {
157 if (mAcquiredBuffers[lockedIdx].mSlot ==
158 BufferQueue::INVALID_BUFFER_SLOT) {
162 assert(lockedIdx < mMaxLockedBuffers);
164 AcquiredBuffer &ab = mAcquiredBuffers.editItemAt(lockedIdx);
166 ab.mBufferPointer = bufferPointer;
167 ab.mGraphicBuffer = mSlots[buf].mGraphicBuffer;
170 reinterpret_cast<uint8_t*>(bufferPointer);
171 nativeBuffer->width = mSlots[buf].mGraphicBuffer->getWidth();
172 nativeBuffer->height = mSlots[buf].mGraphicBuffer->getHeight();
173 nativeBuffer->format = mSlots[buf].mGraphicBuffer->getPixelFormat();
174 nativeBuffer->stride = (ycbcr.y != NULL) ?
175 static_cast<uint32_t>(ycbcr.ystride) :
176 mSlots[buf].mGraphicBuffer->getStride();
178 nativeBuffer->crop = b.mCrop;
179 nativeBuffer->transform = b.mTransform;
180 nativeBuffer->scalingMode = b.mScalingMode;
181 nativeBuffer->timestamp = b.mTimestamp;
182 nativeBuffer->frameNumber = b.mFrameNumber;
184 nativeBuffer->dataCb = reinterpret_cast<uint8_t*>(ycbcr.cb);
185 nativeBuffer->dataCr = reinterpret_cast<uint8_t*>(ycbcr.cr);
186 nativeBuffer->chromaStride = static_cast<uint32_t>(ycbcr.cstride);
187 nativeBuffer->chromaStep = static_cast<uint32_t>(ycbcr.chroma_step);
189 mCurrentLockedBuffers++;
194 status_t CpuConsumer::unlockBuffer(const LockedBuffer &nativeBuffer) {
195 Mutex::Autolock _l(mMutex);
196 size_t lockedIdx = 0;
198 void *bufPtr = reinterpret_cast<void *>(nativeBuffer.data);
199 for (; lockedIdx < static_cast<size_t>(mMaxLockedBuffers); lockedIdx++) {
200 if (bufPtr == mAcquiredBuffers[lockedIdx].mBufferPointer) break;
202 if (lockedIdx == mMaxLockedBuffers) {
203 CC_LOGE("%s: Can't find buffer to free", __FUNCTION__);
207 return releaseAcquiredBufferLocked(lockedIdx);
210 status_t CpuConsumer::releaseAcquiredBufferLocked(size_t lockedIdx) {
214 err = mAcquiredBuffers[lockedIdx].mGraphicBuffer->unlockAsync(&fd);
216 CC_LOGE("%s: Unable to unlock graphic buffer %zd", __FUNCTION__,
220 int buf = mAcquiredBuffers[lockedIdx].mSlot;
221 if (CC_LIKELY(fd != -1)) {
222 sp<Fence> fence(new Fence(fd));
223 addReleaseFenceLocked(
224 mAcquiredBuffers[lockedIdx].mSlot,
225 mSlots[buf].mGraphicBuffer,
229 // release the buffer if it hasn't already been freed by the BufferQueue.
230 // This can happen, for example, when the producer of this buffer
231 // disconnected after this buffer was acquired.
232 if (CC_LIKELY(mAcquiredBuffers[lockedIdx].mGraphicBuffer ==
233 mSlots[buf].mGraphicBuffer)) {
235 buf, mAcquiredBuffers[lockedIdx].mGraphicBuffer,
236 EGL_NO_DISPLAY, EGL_NO_SYNC_KHR);
239 AcquiredBuffer &ab = mAcquiredBuffers.editItemAt(lockedIdx);
240 ab.mSlot = BufferQueue::INVALID_BUFFER_SLOT;
241 ab.mBufferPointer = NULL;
242 ab.mGraphicBuffer.clear();
244 mCurrentLockedBuffers--;
248 void CpuConsumer::freeBufferLocked(int slotIndex) {
249 ConsumerBase::freeBufferLocked(slotIndex);
252 } // namespace android