CpuConsumer.cpp revision 43078e2827211139f0614719c920f3c5bff6c3fa 
1/*
2 * Copyright (C) 2012 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//#define LOG_NDEBUG 0
18#define LOG_TAG "CpuConsumer"
19//#define ATRACE_TAG ATRACE_TAG_GRAPHICS
20
21#include <cutils/compiler.h>
22#include <utils/Log.h>
23#include <gui/BufferItem.h>
24#include <gui/CpuConsumer.h>
25
26#define CC_LOGV(x, ...) ALOGV("[%s] " x, mName.string(), ##__VA_ARGS__)
27//#define CC_LOGD(x, ...) ALOGD("[%s] " x, mName.string(), ##__VA_ARGS__)
28//#define CC_LOGI(x, ...) ALOGI("[%s] " x, mName.string(), ##__VA_ARGS__)
29#define CC_LOGW(x, ...) ALOGW("[%s] " x, mName.string(), ##__VA_ARGS__)
30#define CC_LOGE(x, ...) ALOGE("[%s] " x, mName.string(), ##__VA_ARGS__)
31
32namespace android {
33
34CpuConsumer::CpuConsumer(const sp<IGraphicBufferConsumer>& bq,
35        size_t maxLockedBuffers, bool controlledByApp) :
36    ConsumerBase(bq, controlledByApp),
37    mMaxLockedBuffers(maxLockedBuffers),
38    mCurrentLockedBuffers(0)
39{
40    // Create tracking entries for locked buffers
41    mAcquiredBuffers.insertAt(0, maxLockedBuffers);
42
43    mConsumer->setConsumerUsageBits(GRALLOC_USAGE_SW_READ_OFTEN);
44    mConsumer->setMaxAcquiredBufferCount(static_cast<int32_t>(maxLockedBuffers));
45}
46
47CpuConsumer::~CpuConsumer() {
48    // ConsumerBase destructor does all the work.
49}
50
51
52
53void CpuConsumer::setName(const String8& name) {
54    Mutex::Autolock _l(mMutex);
55    mName = name;
56    mConsumer->setConsumerName(name);
57}
58
59status_t CpuConsumer::setDefaultBufferSize(uint32_t width, uint32_t height)
60{
61    Mutex::Autolock _l(mMutex);
62    return mConsumer->setDefaultBufferSize(width, height);
63}
64
65status_t CpuConsumer::setDefaultBufferFormat(PixelFormat defaultFormat)
66{
67    Mutex::Autolock _l(mMutex);
68    return mConsumer->setDefaultBufferFormat(defaultFormat);
69}
70
71status_t CpuConsumer::setDefaultBufferDataSpace(
72        android_dataspace defaultDataSpace)
73{
74    Mutex::Autolock _l(mMutex);
75    return mConsumer->setDefaultBufferDataSpace(defaultDataSpace);
76}
77
78static bool isPossiblyYUV(PixelFormat format) {
79    switch (static_cast<int>(format)) {
80        case HAL_PIXEL_FORMAT_RGBA_8888:
81        case HAL_PIXEL_FORMAT_RGBX_8888:
82        case HAL_PIXEL_FORMAT_RGB_888:
83        case HAL_PIXEL_FORMAT_RGB_565:
84        case HAL_PIXEL_FORMAT_BGRA_8888:
85        case HAL_PIXEL_FORMAT_Y8:
86        case HAL_PIXEL_FORMAT_Y16:
87        case HAL_PIXEL_FORMAT_RAW16:
88        case HAL_PIXEL_FORMAT_RAW10:
89        case HAL_PIXEL_FORMAT_RAW_OPAQUE:
90        case HAL_PIXEL_FORMAT_BLOB:
91        case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
92            return false;
93
94        case HAL_PIXEL_FORMAT_YV12:
95        case HAL_PIXEL_FORMAT_YCbCr_420_888:
96        case HAL_PIXEL_FORMAT_YCbCr_422_SP:
97        case HAL_PIXEL_FORMAT_YCrCb_420_SP:
98        case HAL_PIXEL_FORMAT_YCbCr_422_I:
99        default:
100            return true;
101    }
102}
103
104status_t CpuConsumer::lockNextBuffer(LockedBuffer *nativeBuffer) {
105    status_t err;
106
107    if (!nativeBuffer) return BAD_VALUE;
108    if (mCurrentLockedBuffers == mMaxLockedBuffers) {
109        CC_LOGW("Max buffers have been locked (%zd), cannot lock anymore.",
110                mMaxLockedBuffers);
111        return NOT_ENOUGH_DATA;
112    }
113
114    BufferItem b;
115
116    Mutex::Autolock _l(mMutex);
117
118    err = acquireBufferLocked(&b, 0);
119    if (err != OK) {
120        if (err == BufferQueue::NO_BUFFER_AVAILABLE) {
121            return BAD_VALUE;
122        } else {
123            CC_LOGE("Error acquiring buffer: %s (%d)", strerror(err), err);
124            return err;
125        }
126    }
127
128    int buf = b.mBuf;
129
130    void *bufferPointer = NULL;
131    android_ycbcr ycbcr = android_ycbcr();
132
133    PixelFormat format = mSlots[buf].mGraphicBuffer->getPixelFormat();
134    PixelFormat flexFormat = format;
135    if (isPossiblyYUV(format)) {
136        if (b.mFence.get()) {
137            err = mSlots[buf].mGraphicBuffer->lockAsyncYCbCr(
138                GraphicBuffer::USAGE_SW_READ_OFTEN,
139                b.mCrop,
140                &ycbcr,
141                b.mFence->dup());
142        } else {
143            err = mSlots[buf].mGraphicBuffer->lockYCbCr(
144                GraphicBuffer::USAGE_SW_READ_OFTEN,
145                b.mCrop,
146                &ycbcr);
147        }
148        if (err == OK) {
149            bufferPointer = ycbcr.y;
150            flexFormat = HAL_PIXEL_FORMAT_YCbCr_420_888;
151            if (format != HAL_PIXEL_FORMAT_YCbCr_420_888) {
152                CC_LOGV("locking buffer of format %#x as flex YUV", format);
153            }
154        } else if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
155            CC_LOGE("Unable to lock YCbCr buffer for CPU reading: %s (%d)",
156                    strerror(-err), err);
157            return err;
158        }
159    }
160
161    if (bufferPointer == NULL) { // not flexible YUV
162        if (b.mFence.get()) {
163            err = mSlots[buf].mGraphicBuffer->lockAsync(
164                GraphicBuffer::USAGE_SW_READ_OFTEN,
165                b.mCrop,
166                &bufferPointer,
167                b.mFence->dup());
168        } else {
169            err = mSlots[buf].mGraphicBuffer->lock(
170                GraphicBuffer::USAGE_SW_READ_OFTEN,
171                b.mCrop,
172                &bufferPointer);
173        }
174        if (err != OK) {
175            CC_LOGE("Unable to lock buffer for CPU reading: %s (%d)",
176                    strerror(-err), err);
177            return err;
178        }
179    }
180
181    size_t lockedIdx = 0;
182    for (; lockedIdx < static_cast<size_t>(mMaxLockedBuffers); lockedIdx++) {
183        if (mAcquiredBuffers[lockedIdx].mSlot ==
184                BufferQueue::INVALID_BUFFER_SLOT) {
185            break;
186        }
187    }
188    assert(lockedIdx < mMaxLockedBuffers);
189
190    AcquiredBuffer &ab = mAcquiredBuffers.editItemAt(lockedIdx);
191    ab.mSlot = buf;
192    ab.mBufferPointer = bufferPointer;
193    ab.mGraphicBuffer = mSlots[buf].mGraphicBuffer;
194
195    nativeBuffer->data   =
196            reinterpret_cast<uint8_t*>(bufferPointer);
197    nativeBuffer->width  = mSlots[buf].mGraphicBuffer->getWidth();
198    nativeBuffer->height = mSlots[buf].mGraphicBuffer->getHeight();
199    nativeBuffer->format = format;
200    nativeBuffer->flexFormat = flexFormat;
201    nativeBuffer->stride = (ycbcr.y != NULL) ?
202            static_cast<uint32_t>(ycbcr.ystride) :
203            mSlots[buf].mGraphicBuffer->getStride();
204
205    nativeBuffer->crop        = b.mCrop;
206    nativeBuffer->transform   = b.mTransform;
207    nativeBuffer->scalingMode = b.mScalingMode;
208    nativeBuffer->timestamp   = b.mTimestamp;
209    nativeBuffer->dataSpace   = b.mDataSpace;
210    nativeBuffer->frameNumber = b.mFrameNumber;
211
212    nativeBuffer->dataCb       = reinterpret_cast<uint8_t*>(ycbcr.cb);
213    nativeBuffer->dataCr       = reinterpret_cast<uint8_t*>(ycbcr.cr);
214    nativeBuffer->chromaStride = static_cast<uint32_t>(ycbcr.cstride);
215    nativeBuffer->chromaStep   = static_cast<uint32_t>(ycbcr.chroma_step);
216
217    mCurrentLockedBuffers++;
218
219    return OK;
220}
221
222status_t CpuConsumer::unlockBuffer(const LockedBuffer &nativeBuffer) {
223    Mutex::Autolock _l(mMutex);
224    size_t lockedIdx = 0;
225
226    void *bufPtr = reinterpret_cast<void *>(nativeBuffer.data);
227    for (; lockedIdx < static_cast<size_t>(mMaxLockedBuffers); lockedIdx++) {
228        if (bufPtr == mAcquiredBuffers[lockedIdx].mBufferPointer) break;
229    }
230    if (lockedIdx == mMaxLockedBuffers) {
231        CC_LOGE("%s: Can't find buffer to free", __FUNCTION__);
232        return BAD_VALUE;
233    }
234
235    return releaseAcquiredBufferLocked(lockedIdx);
236}
237
238status_t CpuConsumer::releaseAcquiredBufferLocked(size_t lockedIdx) {
239    status_t err;
240    int fd = -1;
241
242    err = mAcquiredBuffers[lockedIdx].mGraphicBuffer->unlockAsync(&fd);
243    if (err != OK) {
244        CC_LOGE("%s: Unable to unlock graphic buffer %zd", __FUNCTION__,
245                lockedIdx);
246        return err;
247    }
248    int buf = mAcquiredBuffers[lockedIdx].mSlot;
249    if (CC_LIKELY(fd != -1)) {
250        sp<Fence> fence(new Fence(fd));
251        addReleaseFenceLocked(
252            mAcquiredBuffers[lockedIdx].mSlot,
253            mSlots[buf].mGraphicBuffer,
254            fence);
255    }
256
257    // release the buffer if it hasn't already been freed by the BufferQueue.
258    // This can happen, for example, when the producer of this buffer
259    // disconnected after this buffer was acquired.
260    if (CC_LIKELY(mAcquiredBuffers[lockedIdx].mGraphicBuffer ==
261            mSlots[buf].mGraphicBuffer)) {
262        releaseBufferLocked(
263                buf, mAcquiredBuffers[lockedIdx].mGraphicBuffer,
264                EGL_NO_DISPLAY, EGL_NO_SYNC_KHR);
265    }
266
267    AcquiredBuffer &ab = mAcquiredBuffers.editItemAt(lockedIdx);
268    ab.mSlot = BufferQueue::INVALID_BUFFER_SLOT;
269    ab.mBufferPointer = NULL;
270    ab.mGraphicBuffer.clear();
271
272    mCurrentLockedBuffers--;
273    return OK;
274}
275
276void CpuConsumer::freeBufferLocked(int slotIndex) {
277    ConsumerBase::freeBufferLocked(slotIndex);
278}
279
280status_t CpuConsumer::detachNextBuffer(BufferItem* outItem) {
281    if (outItem == NULL) {
282        return BAD_VALUE;
283    }
284
285    Mutex::Autolock lock(mMutex);
286
287    BufferItem item;
288    status_t result = acquireBufferLocked(&item, 0);
289    if (result != NO_ERROR) {
290        CC_LOGE("%s: Failed to acquire buffer (%d)", __FUNCTION__, result);
291        return result;
292    }
293
294    result = mConsumer->detachBuffer(item.mSlot);
295    if (result != NO_ERROR) {
296        CC_LOGE("%s: Failed to detach buffer (%d)", __FUNCTION__, result);
297        return result;
298    }
299
300    freeBufferLocked(item.mSlot);
301
302    *outItem = item;
303    return NO_ERROR;
304}
305
306status_t CpuConsumer::attachAndReleaseBuffer(const sp<GraphicBuffer>& buffer) {
307    if (buffer == NULL) {
308        return BAD_VALUE;
309    }
310
311    Mutex::Autolock lock(mMutex);
312
313    int slot = -1;
314    status_t result = mConsumer->attachBuffer(&slot, buffer);
315    if (result != NO_ERROR) {
316        CC_LOGE("%s: Failed to attach buffer (%d)", __FUNCTION__, result);
317        return result;
318    }
319
320    // These behaviors must be kept in sync with
321    // BufferQueueConsumer::attachBuffer
322    mSlots[slot].mGraphicBuffer = buffer;
323    mSlots[slot].mFence = Fence::NO_FENCE;
324    mSlots[slot].mFrameNumber = 0;
325
326    result = releaseBufferLocked(slot, buffer, EGL_NO_DISPLAY, EGL_NO_SYNC_KHR);
327    if (result != NO_ERROR) {
328        CC_LOGE("%s: Failed to release buffer (%d)", __FUNCTION__, result);
329        return result
330    }
331
332    return NO_ERROR;
333}
334
335} // namespace android
336